文章目录
- 第 3 天
- const 的使用
- 二值指针
- 指针数组
- 二维数组
第 3 天
一、指针强化
1、指针也是一种数据理想，指针变量也是一种变量，和 int a 本质上是一样的
1） 指针变量也是一种变量，也有空间，32 位程序大小为 4 个字节
int *p = 0x1122;
2) *操作符，*相当于钥匙，可以通过*找到指针所指向的内存区域
int a = 10;
int *p = NULL;
p = &a; // 指针指向谁，就把谁的地址赋值给指针
*p = 22; // 给内存赋值，写内存
int b = *p; // 读内存
3） 指针变量，和指向的内存是两个不同的概念（p：指的是指针的地址，*p 指的是指针p指向的内存区域）
char *p = NULL;
char buf[] = "abcdef";
p = buf;
p = p + 1; // 改变了指向变量的值，改变了指针的指向
*p = 'm'; // 改变了指针指向的内存，并不会影响到指针的值
4) 写内存时，一定要确保内存可写
char *buf = "dsadsad"; // buf指向文字常量区
char buf[] = "dasdasdas";// buf存在于栈区，字符串在文字常量区，存在拷贝
buf[2] = '0'; // 文字常量区，内存不可修改
2、间接赋值（*p）是指针存在的最大意义
1） 间接赋值三大条件
两个变量
建立关系
通过*操作符进行间接赋值
2) 定义合适类型的指针变量
int b;
int *q = &b;
int **t = &q;
如果想通过函数形参改变实参的值，必须通过地址传递；
3） 不允许向NULL和位未知非法地址拷贝内存
char *p = NULL;
strcpy(q, "1234"); // err
char buf[100];
q = buf
strcpy(q, "1234"); //ok
q = (char*)malloc(sizeof(char)*10);
strcpy(q, "1234");// ok
char* q = "1234";
strcpy(q, "abcd"); // 文字常量区不可更改 err
void *p = NULL;
char buf[1024] = "abcd";
p = (void*)buf; // 同类型赋值
printf("%s", (char*)p); // 需要将void转换为对应类型才能输出
4）
预处理：宏定义展开、头文件展开、条件编译
函数注释好习惯：
/*
功能：获取非空字符串
参数：
inbuf：原始字符串buf首地址
outbuf：非空字符串buf首地址
返回值：
成功：0
失败：非0
*/const 的使用
const 修饰一个变量为只读；
从左往右，跳过类型，看修饰哪个字符
如果是* 内存内容不能改变
如果是指针变量 指针值不能改变
const int a = 10;
a = 100; // err
// 区别指针变量，指针指向的内存
char buf[] = "dasdasdf";
// 从左往右，跳过类型，看修饰哪个字符
// 如果是* 内存内容不能改变
// 如果是指针变量 指针值不能改变
const char *p = buf; // == char const *p = buf; 可以指向其他内存空间，但指向内存空间的内容不可以发生改变
p[1] = '2'; // err
p = "dsadsad"; //ok
char * const p2 = buf; // 不可以指向其他内存空间，但指向的内存空间的内容可以发生改变
p2[1] = '2'; //ok
p2 = "sdasdsa "; //err
const char * const p2 = buf; // p2 为只读，不能赋值
extern const int aa; // 在另一个文件中引用，不能赋值，只能声明
// 但仍然可以通过指针修改二值指针
void fun(int **p)
{
// *p 访问指针 p 指向的内容 ;
}
int main()
{
int *p;
fun(&p);
}指针数组
-
char* p[]：元素类型为char*的数组； -
char p[]：元素类型为char的数组；
char *p0 = "111";
char *p1 = "222";
char *p2 = "333";
char *p3 = "444";
char *p[] = {"111", "222"}
for(int i = 0; i < 2; i++)
{
printf("%s\n", p[i]);
}二维数组
void print_array(char a[][30], int n)
{
printf("a:%d, a+1: %d\n", a, a+1);
}
void sort_array(char a[][30], int n)
{
int i = 0;
int j = 0;
char tmp[30];
for(i = 0; i < n; i++)
{
for(j = i + 1; j < n; j++)
{
if(strcmp(a[i], a[j]) < 0)
{
strcpy(tmp, a[i]);
strcpy(a[i], a[j]);
strcpy(a[j], tmp);
}
}
}
}
int main()
{
// char a0[30] = "0000000";
// char a1[30] = "1111111";
// char a2[30] = "2222222";
// char a3[30] = "3333333";
char a[4][30] = {"0000000", "1111111", "2222222", "3333333"};
for(int i = 0; i < 4; i++)
{
printf("%s\n", a[i]);
}
int n = sizeof(a) / sizeof(a[0]);
print_array(a, n);
printf("a:%d, a+1: %d\n", a, a+1);
char b[30];
printf("&b:%d, &b+1:%d\n", &b, &b+1);
printf("b:%d, b+1:%d\n", b, b+1);
sort_array(a, n);
for(int i = 0; i < 4; i++)
{
printf("%s\n", a[i]);
}
return 0;
}0000000
1111111
2222222
3333333
a:6356588, a+1: 6356618
a:6356588, a+1: 6356618
&b:6356558, &b+1:6356588
b:6356558, b+1:6356559
3333333
2222222
1111111
0000000
Process returned 0 (0x0) execution time : 0.109 s
Press any key to continue.
int main()
{
int i = 0;
char* p[10] = {0}; // 是一个长度为10的数组，每个元素是一个未初始化的指针！！！通过动态分配方式赋予指针意义
for(int i = 0; i < 10; i++)
{
p[i] = malloc(100);
strcpy(p[i], "das");
}
int a[10];
int *q = (int *)malloc(10*sizeof(int));
int n = 3;
char **buf = (char **)malloc(n * sizeof(char *)); // 二维指针分部动态分配内存，第一步！！！！
if(buf == NULL)
return -1;
for(i = 0; i < n; i++)
{
buf[i] = (char*)malloc(30*sizeof(char)); // 二维指针分部动态分配内存，第二步！！！！
char str[30];
sprintf(str, "test%d%d", i, i);
strcpy(buf[i], str);
}
for(i = 0; i < n; i++)
{
printf("%s ", buf[i]);
}
for(i = 0; i < n; i++) // 二维指针分布释放内存，第一步！！！
{
free(buf[i]);
buf[i] = NULL;
}
if(buf != NULL) // 二维指针分布释放内存，第二步！！！
{
free(buf);
}
}test00 test11 test22
Process returned 0 (0x0) execution time : 0.101 s
Press any key to continue.
