指针是一种数据类型,占用内存空间,用来保存内存地址。
#define _CRT_SECURE_NO_WARNINGS //VS不建议使用传统的库函数,如果不使用这个宏,会出现一个错误,编号:C4996
#include //std 标准 i-input 输入 o-output 输出
#include //strcp strcmp strcat strstr
#include //std 标准 lib 库 malloc free
void test01() {
int *p1 = 0x1234;
int ***p2 = 0x1111;
printf("p1 size:%d\n", sizeof(p1));
printf("p2 size:%d\n", sizeof(p2));
//指针是变量,指针本身也占内存空间,指针也可以被赋值
int a = 10;
p1 = &a;
printf("p1 address:%p\n", &p1);
printf("p1 address:%p\n", p1);
printf("a address:%p\n", &a);
}
//程序入口
int main() {
test01();
system("pause"); //按任意键暂停,阻塞功能
return EXIT_SUCCESS; //返回 正常退出值 0
}
标准定义了 NULL 指针,它作为一个特殊的指针变量,标识不指向任何东西。要使一个指针为 NULL,可以给它赋值一个零值。为了测试一个指针是否为 NULL,你可以将它与零值进行比较。
对指针解引用操作可以获得它所指向的值。但从定义上看,NULL 指针并为指向任何东西,因为对一个 NULL 指针解引用是一个非法的操作,在解引用之前,必须确保它不是一个 NULL 指针。
如果对一个 NULL 指针间接访问会发生什么呢?结果因编译器而异。
不允许向 NULL 和非法地址拷贝内存:
void test() {
char *p = NULL;
//给p指向的内存区域拷贝内容
strcpy(p, "1111"); //err
char *q = 0x1122;
//给q指向的内存区域拷贝内容
strcpy(q, "2222");//err
}
在使用指针时,要避免野指针的出现:
野指针指向一个已删除的对象或未申请访问受限内存区域的指针。与空指针不同,野指针无法通过简单地判断是否为 NULL 避免,而只能通过养成良好的编程习惯来尽力减少。
对野指针进行操作很容易造成程序错误。
什么情况下会导致野指针?
指针变量未初始化
任何指针变量刚被创建时不会自动成为 NULL 指针,它的缺省值是随机的,它会乱指一气。所以,指针变量在创建的同时应当被初始化,要么将指针设置为 NULL,要么让它指向合法的内存。
指针释放后为置空
有时指针在 free 或 delete 后未赋值 NULL,便会使人以为是合法的。别看 free 和 delete 的名字(尤其是 delete),它们只是把拔指针所指的内存给释放掉,但并没有把指针本身干掉。此时指针指向的就是“垃圾”内存。释放后的指针应立即将指针设置为 NULL,防止产生“野指针”。
指针操作超越变量作用域
不要返回指向栈内存的指针或引用,因为栈内存在函数结束时会被释放。
void test() {
//1、未初始化指针
//int* p;
//printf("%d\n", *p);
//2、malloc后也free了,但是指针没有置空
//int* p = malloc(sizeof(int));
//*p = 100;
//free(p); //野指针
//p = NULL; //将free后的指针要进行置空,防止野指针的出现
//printf("%d\n", *p);
//3、指针的操作超越了变量的作用域
int *p2 = doWork(); //p2就是野指针
printf("%d\n", *p2);
printf("%d\n", *p2);
}
int * doWork()
{
int a = 10;
int *p = &a;
return p;
}
空指针和野指针是否可以被释放
void test() {
int * p = NULL;
free(p); //空指针是可以释放的
free(p);
int* p2 = malloc(4);
free(p2); //野指针是不可以被释放的
free(p2);
}
操作野指针是非常危险的操作,应该规避野指针的出现:
初始化时置 NULL
指针变量一定要初始化为NULL,因为任何指针变量刚被创建时不会自动成为NULL指针,它的缺省值是随机的。
释放时置 NULL
当指针p指向的内存空间释放时,没有设置指针p的值为NULL。delete和free只是把内存空间释放了,但是并没有将指针p的值赋为NULL。通常判断一个指针是否合法,都是使用if语句测试该指针是否为NULL。
通过一个指针访问它所指向的地址的过程叫做间接访问,或者叫解引用指针,这个用于执行间接访问的操作符是*。
注意:对一个int类型指针解引用会产生一个整型值,类似地,对一个float指针解引用会产生了一个float类型的值。
int arr[5];
int *p = * (&arr);
int arr1[5][3] arr1 = int(*)[3]
&arr1
在指针声明时,* 号表示所声明的变量为指针
在指针使用时,* 号表示操作指针所指向的内存空间
1)* 相当通过地址(指针变量的值)找到指针指向的内存,再操作内存
2)* 放在等号的左边赋值(给内存赋值,写内存)
3)* 放在等号的右边取值(从内存中取值,读内存)
//解引用
void test01(){
//定义指针
int* p = NULL;
//指针指向谁,就把谁的地址赋给指针
int a = 10;
p = &a;
*p = 20;//*在左边当左值,必须确保内存可写
//*号放右面,从内存中读值
int b = *p;
//必须确保内存可写
char* str = "hello world!";
*str = 'm';
printf("a:%d\n", a);
printf("*p:%d\n", *p);
printf("b:%d\n", b);
}
指针是一种数据类型,是指它指向的内存空间的数据类型。指针所指向的内存空间决定了指针的步长。指针的步长指的是,当指针+1时候,移动多少字节单位。
思考如下问题:
int a = 0xaabbccdd;
unsigned int *p1 = &a;
unsigned char *p2 = &a;
//为什么*p1打印出来正确结果?
printf("%x\n", *p1);
//为什么*p2没有打印出来正确结果?
printf("%x\n", *p2);
//为什么p1指针+1加了4字节?
printf("p1 =%d\n", p1);
printf("p1+1=%d\n", p1 + 1);
//为什么p2指针+1加了1字节?
printf("p2 =%d\n", p2);
printf("p2+1=%d\n", p2 + 1);
#define _CRT_SECURE_NO_WARNINGS //VS不建议使用传统的库函数,如果不使用这个宏,会出现一个错误,编号:C4996
#include //std 标准 i-input 输入 o-output 输出
#include //strcp strcmp strcat strstr
#include //std 标准 lib 库 malloc free
#include
//指针的步长意义
//1、指针变量+1后,跳跃的字节数量
void test01() {
char * p = NULL;
printf("%d\n", p);
printf("%d\n", p + 1);
double * p2 = NULL;
printf("%d\n", p2);
printf("%d\n", p2 + 1);
}
//2、解引用时候,取的字节数
void test02() {
char buf[1024] = { 0 };
int a = 1000;
memcpy(buf, &a, sizeof(int));
char * p = buf; //通过p找到buf的首地址
printf("buf中的a = %d\n", *(int*)p);
}
//3、自定义数据类型 练习
struct Person
{
char a; //0~3
int b; //4~7
char buf[64]; //8~71
int d; //72~75
};
void test03() {
struct Person p1 = { 'a',10,"Hello World",1000 };
//计算结构体中属性的偏移,利用offsetof(结构体,属性)获取自定义数据类型中属性的偏移
printf("p1.d的偏移量为:%d\n", offsetof(struct Person, d));
//打印d的值
printf("p1.d的值为:%d\n", *(int*)((char*)&p1 + offsetof(struct Person, d)));
}
//程序入口
int main() {
//test01();
//test02();
test03();
system("pause"); //按任意键暂停,阻塞功能
return EXIT_SUCCESS; //返回 正常退出值 0
}
通过指针间接赋值成立的三大条件:
1)2个变量(一个普通变量,一个指针变量,或者一个实参一个形参)
2)建立关系
3)通过 * 操作指针指向的内存
void changeValue(int *p) //a2实参,p形参
{
*p = 1000;
}
void test(){
int a = 100; //两个变量
int *p = NULL;
//建立关系
//指针指向谁,就把谁的地址赋值给指针
p = &a;
//通过*操作内存
*p = 22;
printf("a = %d\n",a2);
int a2 = 10;
changeValue(&a2);
printf("a2 = %d\n",a2);
}
void test(){
int b;
int *q = &b; //0级指针
int **t = &q; //1级指针
int ***a = &t; //2级指针
}
#define _CRT_SECURE_NO_WARNINGS //VS不建议使用传统的库函数,如果不使用这个宏,会出现一个错误,编号:C4996
#include //std 标准 i-input 输入 o-output 输出
#include //strcp strcmp strcat strstr
#include //std 标准 lib 库 malloc free
int func1() { return 10; }
void func2(int a) {
a = 100;
}
//指针的意义—间接赋值
void test01() {
int a = 0;
a = func1();
printf("a = %d\n", a);
func2(a);
printf("a = %d\n", a); //此处的a还是10,因为func2中的a形参,a = 100是给形参赋值了
}
void func3(int* a){
*a = 100;
}
void test02(){
int a = 0;
a = func1();
printf("a = %d\n", a);
func3(&a);
printf("a = %d\n", a);
}
//程序入口
int main() {
//test01();
test02();
system("pause"); //按任意键暂停,阻塞功能
return EXIT_SUCCESS; //返回 正常退出值 0
}
void AllocateSpace(char** p){
*p = (char*)malloc(100);
strcpy(*p,"hello world!");
}
void FreeSpace(char** p){
if(p == NULL){
return;
}
if(*p != NULL){
free(*p);
*p = NULL;
}
}
void test(){
char* p = NULL;
AllocateSpace(&p);
printf("%s\n", p);
FreeSpace(&p);
if(p == NULL){
printf("内存释放!\n");
}
}
指针做函数参数,具备输入和输出特性:
输入:主调函数分配内存
输出:被调函数分配内存
#define _CRT_SECURE_NO_WARNINGS //VS不建议使用传统的库函数,如果不使用这个宏,会出现一个错误,编号:C4996
#include //std 标准 i-input 输入 o-output 输出
#include //strcp strcmp strcat strstr
#include //std 标准 lib 库 malloc free
//1、输入特性:主调函数中分配内存,被调函数中使用内存
void func(char* p) {
strcpy(p, "hello world");
}
void test01() {
//分配到栈上
char buf[1024] = { 0 };
func(buf);
printf("%s\n", buf);
}
void printString(char * str) {
printf("%s\n", str);
}
void test02() {
//分配到堆区
char * p = malloc(sizeof(char) * 64);
memset(p, 0, 64);
strcpy(p, "hello world");
printString(p);
}
//程序入口
int main() {
//test01();
test02();
system("pause"); //按任意键暂停,阻塞功能
return EXIT_SUCCESS; //返回 正常退出值 0
}
#define _CRT_SECURE_NO_WARNINGS //VS不建议使用传统的库函数,如果不使用这个宏,会出现一个错误,编号:C4996
#include //std 标准 i-input 输入 o-output 输出
#include //strcp strcmp strcat strstr
#include //std 标准 lib 库 malloc free
//2、输出特性:被调函数分配内存,主调函数使用内存
void allocateSpace(char ** pp) {
char * temp = malloc(sizeof(char) * 64);
memset(temp, 0, 64);
strcpy(temp, "hello world");
*pp = temp;
}
void test03() {
char *p = NULL;
allocateSpace(&p);
printf("%s\n", p);
}
//程序入口
int main() {
test03();
system("pause"); //按任意键暂停,阻塞功能
return EXIT_SUCCESS; //返回 正常退出值 0
}
//字符串基本操作
//字符串是以0或者'\0'结尾的字符数组,(数字0和字符'\0'等价)
void test01(){
//字符数组只能初始化5个字符,当输出的时候,从开始位置直到找到0结束
char str1[] = {'h','e','l','l','o'};
printf("%s\n",str1);
//字符数组部分初始化,剩余填0
char str2[100] = {'h','e','l','l','o'};
printf("%s\n",str2);
//如果以字符串初始化,那么编译器默认会在字符串尾部添加'\0'
char str3[]="hello";
printf("%s\n",str3);
printf("sizeof str:%d\n",sizeof(str3));
printf("strlen str:%d\n",strlen(str3));
//sizeof 计算数组大小,数组包含'\0'字符
//strlen 计算字符串的长度,到'\0'结束
//那么如果我这么写,结果是多少呢?
char str4[100]="hello";
printf("sizeof str:%d\n",sizeof(str4));
printf("strlen str:%d\n",strlen(str4));
//请问下面输出结果是多少?sizeof 结果是多少?strlen结果是多少?
char str5[]="hello\0wolrd";
printf("%s\n",str5);
printf("sizeof str:%d\n",sizeof(str5));
printf("strlen str:%d\n",strlen(str5));
//再请问下面输出结果是多少?sizeof 结果是多少?strlen结果是多少?
char str6[]="hello\012wolrd"; // \012是宝进制下转十进制的10,在ASCII表中对应的是换行
printf("%s\n",str6);
printf("sizeof str:%d\n",sizeof(str6));
printf("strlen str:%d\n",strlen(str6));
}
在C中有两种特殊的字符,八进制转义字符和十六进制转义字符,八进制字符的一般形式是’\ddd’,d是0-7的数字。十六进制字符的一般形式是’\xhh’,h是0-9或A-F内的一个。八进制字符和十六进制字符表示的是字符的ASCII码对应的数值。
比如 :
‘\063’表示的是字符’3’,因为’3’的ASCII码是30(十六进制),48(十进制),63(八进制)。
‘\x41’表示的是字符’A’,因为’A’的ASCII码是41(十六进制),65(十进制),101(八进制)。
//拷贝方法1
void copy_string01(char* dest, char* source)
{
int len = strlen(source);
for (int i = 0; source[i] != '\0'; i++)
{
dest[i] = source[i];
}
dest[len] = '\0';
}
//拷贝方法2
void copy_string02(char* dest, char* source)
{
while (*source != '\0' /**source!=0*/) {
*dest = *source;
source++;
dest++;
}
*dest = '\0';
}
//拷贝方法3
void copy_string03(char* dest, char* source)
{
//判断*dest是否为0,0则退出循环
while (*dest++ = *source++) {}
}
void test02() {
char * str = "Hello World";
char buf[1024];
//copy_string01(buf, str);
//copy_string02(buf, str);
copy_string03(buf, str);
printf("%s\n", buf);
}
//第一种方式,利用[ ]进行反转
void reverseString01(char * str)
{
int len = strlen(str);
//起始位置下标
int start = 0;
//结束位置的下标
int end = len - 1;
while (start<end)
{
char temp = str[start];
str[start] = str[end];
str[end] = temp;
start++;
end--;
}
}
//第二种方式 利用指针
void reverseString02(char * str)
{
int len = strlen(str);
//起始位置下标
char * start = str;
//结束位置的下标
char * end = str + len - 1;
while (start<end)
{
char temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
}
void test03() {
char str[] = "abcdefg";
//reverseString01(str);
reverseString02(str);
printf("%s\n", str);
}
int sprintf(char *str,const char *format,...);
功能:
根据参数 format 字符串来转换并格式化数据,然后将结果输出到 str 指定的空间中,知道出现字符串结束符'\0'为止。
参数:
str:字符串首地址
format:字符串格式,用法和printf()一样
返回值:
成功:实际格式化的字符个数
失败:-1
void test04() {
//1、格式化字符串
char buf[1024] = { 0 };
sprintf(buf, "你好,%s,欢迎加入我们!", "John");
printf("buf:%s\n", buf);
memset(buf, 0, 1024);
sprintf(buf, "我今年%d岁了!", 20);
printf("buf:%s\n", buf);
//2、拼接字符串
memset(buf, 0, 1024);
char str1[] = "hello";
char str2[] = "wolrd";
int len = sprintf(buf, "%s%s", str1, str2); //返回的是字符串的长度
printf("buf:%s len:%d\n", buf, len);
//3、数字转字符串
memset(buf, 0, 1024);
int num = 100;
sprintf(buf, "%d", num);
printf("buf:%s\n", buf);
//设置宽度,右对齐
memset(buf, 0, 1024);
sprintf(buf, "%8d", num);
printf("buf:%s\n", buf);
//设置宽度,左对齐
memset(buf, 0, 1024);
sprintf(buf, "%-8d", num);
printf("buf:%s\n", buf);
//转成16进制字符串小写
memset(buf, 0, 1024);
sprintf(buf, "0x%x", num);
printf("buf:%s\n", buf);
//转成八进制字符串
memset(buf, 0, 1024);
sprintf(buf, "0%o", num);
printf("buf:%s\n", buf);
}
int sscanf(const char *str,const char *format,...);
功能:
从str指定的字符串读取数据,并根据参数 format 字符串来转换并格式化数据。
参数:
str:指定的字符串首地址
format:字符串格式,用法和scanf()一样
返回值:
成功:成功则返回参数数目
失败:-1
格式 | 作用 |
---|---|
%*s 或 % *d | 跳过数据 |
%[width]s | 读指定宽度的数据 |
%[a-z] | 匹配 a 到 z 中任意字符(尽可能多的匹配) |
%[aBc] | 匹配a、B、c中一员,贪婪性 |
%[ ^a ] | 匹配非a的任意字符,贪婪性 |
%[ ^a-z ] | 表示读取除a-z以外的所有字符 |
//1、%*s或%*d 跳过数据
void test05() {
char * str = "12345abcde";
char buf[1024] = { 0 };
sscanf(str,"%*d%s",buf);
printf("%s\n", buf);
}
void test06() {
char * str = "12345abcde"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
//sscanf(str, "%*s%s", buf);
sscanf(str, "%*[a-z]%s", buf);
printf("%s\n", buf);
}
//2、%[width]s 读取指定宽度的数据
void test07() {
char * str = "abcde12345"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
sscanf(str, "%6s", buf);
printf("%s\n", buf);
}
//3、%[a-z] 匹配 a 到 z 中任意字符(尽可能多的匹配)
void test08() {
char * str = "12345abcde"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
sscanf(str, "%*d%[a-c]", buf);
printf("%s\n", buf); //abc
}
//4、%[aBc] 匹配a、B、c中一员,贪婪性
void test09() {
char * str = "aabcde12345"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
sscanf(str, "%[aBc]", buf); //在匹配过程中,只要有一个匹配失败,后续就不在进行匹配了
printf("%s\n", buf); //aa
}
//5、%[ ^a ] 匹配非a的任意字符,贪婪性
void test10() {
char * str = "aabcde12345"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
sscanf(str, "%[^c]", buf); //在匹配过程中,只要有一个匹配失败,后续就不在进行匹配了
printf("%s\n", buf); //aab
}
//6、%[ ^a-z ] 表示读取除a-z以外的所有字符
void test11() {
char * str = "aabcde12345"; //在中间加空格或者\t都可实现效果
char buf[1024] = { 0 };
sscanf(str, "%[^0-9]", buf); //在匹配过程中,只要有一个匹配失败,后续就不在进行匹配了
printf("%s\n", buf); //aabcde
}
void test(){
char buf[3] = "abc";
printf("buf:%s\n",buf);
}
void test(){
char *p = (char *)malloc(50);
char buf[] = "abcdef";
int n = strlen(buf);
int i = 0;
for (i = 0; i < n; i++)
{
*p = buf[i];
p++; //修改原指针指向
}
free(p);
}
char *get_str()
{
char str[] = "abcdedsgads"; //栈区,
printf("[get_str]str = %s\n", str);
return str;
}
void test(){
char *p = NULL;
p = (char *)malloc(50);
strcpy(p, "abcdef");
if (p != NULL)
{
//free()函数的功能只是告诉系统 p 指向的内存可以回收了
// 就是说,p 指向的内存使用权交还给系统
//但是,p的值还是原来的值(野指针),p还是指向原来的内存
free(p);
}
if (p != NULL)
{
free(p);
}
}
//const修饰变量
void test01(){
//1. const基本概念
const int i = 0;
//i = 100; //错误,只读变量初始化之后不能修改
//2. 定义const变量最好初始化
const int j;
//j = 100; //错误,不能再次赋值
//3. c语言的const是一个只读变量,并不是一个常量,可通过指针间接修改
const int k = 10;
//k = 100; //错误,不可直接修改,我们可通过指针间接修改
printf("k:%d\n", k);
int* p = &k;
*p = 100;
printf("k:%d\n", k);
}
//const 修饰指针
void test02(){
int a = 10;
int b = 20;
//const放在*号左侧 修饰p_a指针指向的内存空间不能修改,但可修改指针的指向
const int* p_a = &a;
//*p_a = 100; //不可修改指针指向的内存空间
p_a = &b; //可修改指针的指向
//const放在*号的右侧, 修饰指针的指向不能修改,但是可修改指针指向的内存空间
int* const p_b = &a;
//p_b = &b; //不可修改指针的指向
*p_b = 100; //可修改指针指向的内存空间
//指针的指向和指针指向的内存空间都不能修改
const int* const p_c = &a;
}
//const指针用法
struct Person{
char name[64];
int id;
int age;
int score;
};
//每次都对对象进行拷贝,效率低,应该用指针
void printPersonByValue(struct Person person){
printf("Name:%s\n", person.name);
printf("Name:%d\n", person.id);
printf("Name:%d\n", person.age);
printf("Name:%d\n", person.score);
}
//但是用指针会有副作用,可能会不小心修改原数据
void printPersonByPointer(const struct Person *person){
printf("Name:%s\n", person->name);
printf("Name:%d\n", person->id);
printf("Name:%d\n", person->age);
printf("Name:%d\n", person->score);
}
void test03(){
struct Person p = { "Obama", 1101, 23, 87 };
//printPersonByValue(p);
printPersonByPointer(&p);
}