C语言学习笔记

1.int* a；和int *a 分别表示什么意思？

int* a 表示定义一个a类型的int指针，int *a 则表示a为一个指针，指向一个int类型的变量。
int* a,b; 等价于 int *a；int b；而不等价于 int *a; int *b;

所以，为了避免出现这样的歧义，很多书上都进行了规范处理，统一将星号靠近变量名，也就是写成

int *p;

2.malloc函数是什么？

malloc功能是内存的动态存储区中分配一个长度为size的连续空间，返回指向这块内存的起始位置的指针。
同时上述只是声明，内存块内的内容或值并没有初始化，是未确定的。
扩展：

free(void *) 表示将此块内存区域释放掉，只有堆的内存才能调用此方法
realloc(void *,size_t) 表示之前申请的内存可能不够，重新扩大此快内存区域
calloc(size_t,size_t) 表示在内存中分配一块长度为size 的连续空间，跟malloc的区别就是，他会将内存区域初始化为零。

一般调用了free函数释放内存空间后，还需要将指针置为NULL ，否则该指针就是悬空指针。

 int a = 8;
 int *ptr_a = &a;
 free(ptr_a);
 ptr_a = NULL;

&运算符，用于取一个对象的地址
*是一个间接寻址符，用于访问指针指向地址的值。

&与*是一对互逆运算符

int a = 8;
int *ptr_a = &a;
printf("a 的地址是%p\n",&a);
printf("ptr_a的地址 =%p\n",ptr_a);

打印结果为：

a 的地址是000000000022FE44
ptr_a的地址 =000000000022FE44

3.占位符

符号	描述
%p	可填充内存地址
%d	可填充带符号10进制整数
%ld	可填long类型的数
%c	可填char类型的数据
%.2f	可填float类型的数据
%.2lf	可填double类型的数据

4.指针的运算

• 对于变量，不同的类型，占用的空间大小是不一样
• 对于相同类型的指针变量，它们占用的空间都是相同的

5.数组与指针

数组名的地址就是数组的起始地址，也是第一个元素的地址，数组名就是一个常量指针。

    int arr[10] = {1,2,3,4};
    int *ptr_arr = arr;
    printf("arr    = %p   \n",arr);
    printf("&arr    = %p   \n",&arr);
    printf("&arr[0] = %p   \n",&arr[0]);
    printf("ptr_arr = %p   \n",ptr_arr);

    打印结果为
     arr    = 000000000022FE20
    &arr    = 000000000022FE20
    &arr[0] = 000000000022FE20
    ptr_arr = 000000000022FE20

这里的arr+1 是在加了一个数组长度

6.可以通过数组的指针操作数组

int arr[10] = {1,2,3,4,5,6,7};
int *ptr_arr = arr;

printf("arr[2] = %d   \n",arr[2]);
ptr_arr[2] = 100;
printf("arr[2] = %d   \n",arr[2]);
*(ptr_arr + 3) = 12;//这里的+3表示指针向右移动三位，即表示将ptr_arr[0+3]指向的元素值改为12.
printf("arr[3] = %d   \n",arr[3]);

打印结果为：
arr[2] = 3
arr[2] = 100
arr[3] = 12

7.数组名称可以当第一个元素的指针用

数组名是一个指针常量，可以进行+1运算，但不能进行++运算。

8.数组指针和指针数组的区别

       数组指针,就是数组的指针，它实质是一个指针，指向的是一个数组（实际是指向该数组的第一个元素的地址），该指针的+1或者-1操作是以数组的长度为基本单位。以下代码的pDouble变量就是就是一个数组指针。

double salarys[] = {18.44,90.45,12.78,66.32,91};
double *ptr_salary = &salarys[0];
double (*pDouble)[5] = &salarys;

从字面上分析double (*pDouble)[5]，pDouble首先被*修饰，就说明它是个指针，double 修饰的数组的类容。

       指针数组，就是元素都是指针的数组，它实质是一个数组，数组元素都是指针。以下变量p1就是一个指针数组

int *p1[5];

从字面上分析，由于[]的优先级高于*,所有p1首先与[]结合组成一个数组，这个数组元素的类型是（int *）。

9.指针常量和常量指针的区别

const 在*号左边，修饰的是指针指向的值，也就是这个指针指向的值是常量，这个指针指向的值不能通过指针更改。但指针的指向可以更改。

const  int* pInt;
int const *pInt1;

注：这个指针指向的值只是不能通过该指针去修改，但仍然可以通过值得变量名称去修改。
如

int a = 100;
const  int* pInt = &a;
*pInt = 200;//错误写法，编译不过
a = 200;//正确写法

const 在*号右边，修饰的是指针变量本身，说明变量的内存地址不可改变，也就是指针的指向不可改变。

int *const pInt2;
const int *const pInt3;//这个说明指针指向不可改变，指针指向的值也不可改变

10.用字符指针表示字符串跟字符串的区别

char *str = "hello";
char str1[10] = "hello";

第一行代码表示在数据区分配一块内存存放“hello”（末尾有\0），再在栈分配一块内存存放str，并指向数据区“hello”中的“h”。
第二行代码表示在数据区分配一块内存存放“hello”（这里跟第一行代码可以共用数据区的同一块内存）。再在栈分配连续的10块内存，再把堆内存中的“hello”各个字符元素复制到占中对应的内存中。

现在如果用str1[1] = 'E’去修改字符串，因为str1[1] 的数据在栈中，可以修改。
但是如果用str[1] = 'E’去修改字符串，就无法修改了，因为str[1]的值在数据区，是常量。

11.在函数中，如果想跨栈修改值，可以用指针传递实现。

void modify(int i){
    i = 100;
}

int main(){
    int a = 10;
    modify(a);
    printf("  a = %d ",a);
    return  0;
}

如在以上代码中，main函数和modify函数中的变量数据都存储在不同的栈中，在modify中将传入的a改为100是做不到的。可以改为以下代码，用传递指针实现。

void modify(int *i){
    *i = 100;
}

int main(){
    int a = 10;
    modify(&a);
    printf("  a = %d ",a);
    return  0;
}

12.指针作为函数返回值。

13.函数指针。

指向函数的指针，写法为

int *p(int a);//这时一个指向返回值为int，参数为一个int类型函数的指针。

函数名就是函数的首地址，函数指针直接用函数赋值就好，如

int modify(int i){
    printf(" 输入的值为  %d",i);
    return i+100;
}

int main(){
    int (*p)(int i) ;//注意这里（*p）必须用括号包裹起来
    p = modify;
    int result = p(1000);
    printf("\n 结果为  %d ",result);
    return  0;
}

14.二维数组和指针。

看以下代码，*p == array且array == p[0]，都是二维数组第一个元素的地址，所以p[0] == *p，所以可以通过p[0][m][n]来访问二维数组

int main() {
    int array[2][3] = {{1, 2, 3},
                       {4, 5, 6}};
    int (*p)[2][3] = &array;

    if (*p == array) {
        printf(" 输入的值为  *p == array  \n");
    }
    if (array == p[0]) {
        printf(" 输入的值为  *p == array  \n");
    }
    if (p[0] == *p) {
        printf(" 输入的值为  p[0] == *p  \n");
    }

    printf("______________________________________________ \n");
    printf("p[0][0] 地址        %d \n", (p[0][0][0]));
    printf("p[0][1] 地址        %d \n", (p[0][0][1]));
    printf("p[0][2] 地址        %d \n", (p[0][0][2]));
    printf("p[1][0] 地址        %d \n", (p[0][1][0]));
    printf("p[1][1] 地址        %d \n", (p[0][1][1]));
    printf("p[1][2] 地址        %d \n", (p[0][1][2]));
}

15.宏的定义以及带参宏。

1.宏定义指令：

#define 宏名 字符串

• #表示这是一条预处理命令
• 宏名是一个标识符，要符合标识符的命名规则，并要求大写
• 字符串的位置可以是常量，表达式，格式字符串

#undef 的作用是结束宏定义的作用域。

在使用宏的时候，系统只会将宏名用字符串部分进傻瓜式的替换 ,如

#define MESSAGEINFO "你好"
int main() {
    printf("MESSAGEINFO = %s \n",MESSAGEINFO);
    return 0;
}

打印结果为

MESSAGEINFO = 你好

2.带参宏
定义：相当于函数，SUM为宏名称，后面接小括号，括号内是参数。然后空格，空格后面也是小括号，括号内为操作逻辑。

#define SUM(a,b) (a*b)

使用：

int main() {
    int i = SUM(5, 9);
    printf("i = %d \n",i);
    int j = SUM(2+3,4+5);
    printf("i = %d \n",j);
    return 0;
}

打印结果为：

i = 45
j = 19

这里i = 45很好解释，5x9=45；但j=19是不是有点难理解，再返回前面介绍看看，宏只是系统傻瓜式的替换。替换的结果是2+3*4+5，所以结果是19。如果想得到先进行加法运算的结果，我们可以这么定义

#define SUM(a,b) ((a)*(b))

运行结果

i = 45
j = 45