精华内容
下载资源
问答
  • 深入理解C语言指针

    万次阅读 多人点赞 2019-09-28 08:36:51
    一、指针的概念 要知道指针的概念,要先了解变量在内存中如何存储的。在存储时,内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针,就像酒店的门牌号一样。 1.1、变量和地址 先写一段...

    一、指针的概念

    要知道指针的概念,要先了解变量在内存中如何存储的。在存储时,内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针,就像酒店的门牌号一样。

    1.1、变量和地址

    先写一段简单的代码:

    void main(){
    	int x = 10, int y = 20;
    }
    

    这段代码非常简单,就是两个变量的声明,分别赋值了 10、20。我们把内存当做一个酒店,而每个房间就是一块内存。那么“int x = 10;”和“int y = 20;”的实际含义如下:

    1. 去酒店订了两个房间,门牌号暂时用 px、py 表示
    2. 让 10 住进 px,让 20 住进 py
    3. 其中门牌号就是 px、py 就是变量的地址
    4. x 和 y 在这里可以理解为具体的房间,房间 x 的门牌号(地址)是 px,房间 y 的门牌号(地址)是 py。而 10 和 20,通过 px、py 两个门牌,找到房间,住进 x、y。用户(变量的值)和房间(变量)以及房间号(指针、地址)的关系

    1.2、指针变量和指针的类型

    指针变量就是一个变量,它存储的内容是一个指针。如果用前面的例子,可以理解为指针变量就是一张房卡,房卡存储了房间号的信息。

    在我们定义一个变量的时候,要确定它的类型。int x、char ch、float、、、在定义指针变量时也是一样的,必须确定指针类型。int 变量的指针需要用 int 类型的指针存储,float 变量的指针需要用 float 类型的指针存储。就像你只能用酒店 A 的房卡存储酒店 A 中房间号的信息一样。

    二、变量的指针与指针变量

    变量的指针就是变量的存储地址,指针变量就是存储指针的变量。

    2.1、指针变量的定义及使用

    (1)指针变量的定义

    指针变量的定义形式如:数据类型 *指针名;例如:

    //分别定义了 int、float、char 类型的指针变量
    int *x;
    float *f;
    char *ch;
    

    如上面的定义,指针变量名为 x、f、ch。并不是*x、*f、*ch

    (2)指针变量的使用

    • 取地址运算符&:单目运算符&是用来取操作对象的地址。例:&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址(因为它们存储在存储器中,没有地址)。
    • 指针运算符*(间接寻址符):与&为逆运算,作用是通过操作对象的地址,获取存储的内容。例:x = &i,x 为 i 的地址,*x 则为通过 i 的地址,获取 i 的内容。

    代码示例:

    //声明了一个普通变量 a
    int a;
    //声明一个指针变量,指向变量 a 的地址
    int *pa;
    //通过取地址符&,获取 a 的地址,赋值给指针变量
    pa = &a;
    //通过间接寻址符,获取指针指向的内容
    printf("%d", *pa);
    

    (3)“&”和“*”的结合方向

    “&”和“*”都是右结合的。假设有变量 x = 10,则*&x 的含义是,先获取变量 x 的地址,再获取地址中的内容。因为“&”和“*”互为逆运算,所以 x = *&x。

    接下来做个小练习,输入 x、y 两个整数,然后将其中的值大的赋值给 x,小的赋值给 y。即:假设输入 x = 8,y = 9。就将 9 赋值给 x,8 赋值给 y。

    void main(){
    	//声明两个普通变量
    	int x, y;
    	//声明两个指针变量
    	int *px, *py;
    	//声明一个临时变量,用于交换
    	int t;
    	//输入两个值,赋值给 x、y
    	scanf("%d", &x);
    	scanf("%d", &y);
    	//给指针变量 px、py 赋初值(关联变量 x、y)
    	px = &x;
    	py = &y;
    	//利用指针来对比 x、y 的值,如果 x 的值比 y 的值小,就交换
    	if(*px < *py){
    		//交换步骤,其中*px == x、*py == y
    		t = *px;
    		*px = *py;
    		*py = t;
    	}
    	printf("x =  %d, y = %d", *px, *py);
    }
    
    输入:23 45
    输出结果为:x = 45, y = 23
    

    2.2、指针变量的初始化

    指针变量与其它变量一样,在定义时可以赋值,即初始化。也可以赋值“NULL”或“0”,如果赋值“0”,此时的“0”含义并不是数字“0”,而是 NULL 的字符码值。

    //利用取地址获取 x 的地址,在指针变量 px 定义时,赋值给 px
    int x;
    int *px = &x;
    //定义指针变量,分别赋值“NULL”和“0”
    int *p1= NULL, *p2 = 0;
    

    2.3、指针运算

    (1)赋值运算

    指针变量可以互相赋值,也可以赋值某个变量的地址,或者赋值一个具体的地址

    int *px, *py, *pz, x = 10;
    //赋予某个变量的地址
    px = &x;
    //相互赋值
    py = px;
    //赋值具体的地址
    pz = 4000;
    

    (2)指针与整数的加减运算

    1. 指针变量的自增自减运算。指针加 1 或减 1 运算,表示指针向前或向后移动一个单元(不同类型的指针,单元长度不同)。这个在数组中非常常用。
    2. 指针变量加上或减去一个整形数。和第一条类似,具体加几就是向前移动几个单元,减几就是向后移动几个单元。
    //定义三个变量,假设它们地址为连续的,分别为 4000、4004、4008
    int x, y, z;
    
    //定义一个指针,指向 x
    int *px = &x;
    
    //利用指针变量 px 加减整数,分别输出 x、y、z
    printf("x = %d", *px);		//因为 px 指向 x,所以*px = x
    
    //px + 1,表示,向前移动一个单元(从 4000 到 4004)
    //这里要先(px + 1),再*(px + 1)获取内容,因为单目运算符“*”优先级高于双目运算符“+”
    printf("y = %d", *(px + 1));		
    printf("z = %d", *(px + 2));
    

    (3)关系运算

    假设有指针变量 px、py。

    1. px > py 表示 px 指向的存储地址是否大于 py 指向的地址
    2. px == py 表示 px 和 py 是否指向同一个存储单元
    3. px == 0 和 px != 0 表示 px 是否为空指针
    //定义一个数组,数组中相邻元素地址间隔一个单元
    int num[2] = {1, 3};
    
    //将数组中第一个元素地址和第二个元素的地址赋值给 px、py
    int *px = &num[0], *py = &num[1];
    int *pz = &num[0];
    int *pn;
    
    //则 py > px
    if(py > px){
    	printf("py 指向的存储地址大于 px 所指向的存储地址");
    }
    
    //pz 和 px 都指向 num[0]
    if(pz == px){
    	printf("px 和 pz 指向同一个地址");
    }
    
    //pn 没有初始化
    if(pn == NULL || pn == 0){
    	printf("pn 是一个空指针");
    }
    

    三、指针与数组

    之前我们可以通过下标访问数组元素,学习了指针之后,我们可以通过指针访问数组的元素。在数组中,数组名即为该数组的首地址,结合上面指针和整数的加减,我们就可以实现指针访问数组元素。

    3.1、指向数组的指针

    如以下语句:

    int nums[10], *p;
    

    上面语句定义了一个数组 nums,在定义时分配了 10 个连续的int 内存空间。而一个数组的首地址即为数组名nums,或者第一个元素的首地址也是数组的首地址。那么有两种方式让指针变量 p 指向数组 nums:

    //数组名即为数组的首地址
    p = nums;
    //数组第一个元素的地址也是数组的首地址
    p = &nums[0];
    

    上面两句是等价的。
    如下几个操作,用指针操作数组:

    1. *p = 1,此操作为赋值操作,即将指针指向的存储空间赋值为 1。此时 p 指向数组 nums 的第一个元素,则此操作将 nums 第一个元素赋值为 0,即 nums[0] = 1。
    2. p + 1,此操作为指针加整数操作,即向前移动一个单元。此时 p + 1 指向 nums[0]的下一个元素,即 nums[1]。通过p + 整数可以移动到想要操作的元素(此整数可以为负数)。
    3. 如上面,p(p + 0)指向 nums[0]、p + 1 指向 nums[1]、、、类推可得,p+i 指向 nums[i],由此可以准确操作指定位置的元素。
    4. 在 p + 整数的操作要考虑边界的问题,如一个数组长度为 2,p+3 的意义对于数组操作来说没有意义。

    下面写一段代码,用指针访问数组的元素:

    //定义一个整形数组,并初始化
    int nums[5] = {4, 5, 3, 2, 7};
    
    //定义一个指针变量 p,将数组 nums 的首地址赋值给 p,也可以用p = &nums[0]赋值
    int *p = nums, i;			//i 作为循环变量
    
    //p 指向数组第一个元素(数组首地址),我们可以直接用间接寻址符,获取第一个元素的内容
    printf("nums[0] = %d\n", *p);			//输出结果为 nums[0] = 4
    
    //我们可以通过“p + 整数”来移动指针,要先移动地址,所以 p + 1 要扩起来
    printf("nums[1] = %d\n", *(p + 1));		//输出结果为 nums[1] = 5
    
    //由上面推导出*(p + i) = nums[i],所以我们可以通过 for 循环变量元素
    for(i = 0; i < 5; i++){
    	printf("nums[%d] = %d", i, *(p + i));
    }
    

    注:数组名不等价于指针变量,指针变量可以进行 p++和&操作,而这些操作对于数组名是非法的。数组名在编译时是确定的,在程序运行期间算一个常量。

    3.2、字符指针与字符数组

    在 C 语言中本身没有提供字符串数据类型,但是可以通过字符数组和字符指针的方式存储字符串。

    (1)字符数组方式

    这个在前面应该学习过,这里就不赘述了。

    char word[] = "zack";
    printf("%s", word);
    

    (2)字符指针方式

    指针方式操作字符串和数组操作字符串类似,可以把定义的指针看做是字符数组的数组名。在内存中存储大致如下,这里为了方便换了个字符串:在这里插入图片描述

    //除了定义一个字符数组外,还可以直接定义一个字符指针存储字符串
    char *sentence = "Do not go gentle into that good night!";
    
    //此时可以做字符串的操作
    //输出
    printf("%s", sentence);
    
    //通过下标取字符
    printf("%c", sentence[0]);
    
    //获取字符串长度,其中 strlen 是 string.h 库中的方法
    printf("%d", strlen(sentence));
    

    注:字符指针方式区别于字符数组方式,字符数组不能通过数组名自增操作,但是字符指针是指针,可以自增操作。自增自减少会实现什么效果大家可以自己尝试运行一下

    下面做个小练习,利用字符指针将字符数组 sentence 中的内容复制到字符数组 word 中:

    //定义字符数组 sentence 和 word,给 sentence 赋初值
    char sentence[] = "Do not go gentle into that good night!", word[100];
    
    //定义字符指针,指向 word
    char *ch = word;
    int i;
    
    //循环赋值
    for(i = 0; sentence[i] != '\0'; i++){
    	*(ch + i) = sentence[i];
    }
    
    //在当 i 等于 sentence 的长度(sentence 的长度不包含'\0')时,
    //i 继续自增,此时判断 sentence[0] != '\0'不符合,跳出循环,则 i 比 sentence 长度大 1
    *(ch + i) = '\0';
    
    //输出字符串,因为 ch 指向 word,所以输出结果是一样的
    printf("ch = %s, word = %s", ch, word);
    

    注:指针变量必须初始化一个有效值才能使用

    3.3、多级指针及指针数组

    (1)多级指针

    指针变量作为一个变量也有自己的存储地址,而指向指针变量的存储地址就被称为指针的指针,即二级指针。依次叠加,就形成了多级指针。我们先看看二级指针,它们关系如下:指针变量 p 指向变量 x,二级指针变量指向指针变量 p
    其中 p 为一级指针,pp 为二级指针。二级指针定义形式如下:

    数据类型 **二级指针名;
    

    和指针变量的定义类似,由于*是右结合的,所以*pp 相当于*(*p)。在本次定义中,二级指针的变量名为 pp,而不是**p。多级指针的定义就是定义时使用多个“*”号。下面用一个小程序给大家举例:

    //定义普通变量和指针变量
    int *pi, i = 10;
    //定义二级指针变量
    int **ppi;
    
    //给指针变量赋初值
    pi = &i;
    
    //给二级指针变量赋初值
    ppi = &pi;
    
    //我们可以直接用二级指针做普通指针的操作
    //获取 i 的内容
    printf("i = %d", **ppi);
    //获取 i 的地址
    printf("i 的地址为%d", *ppi);
    

    注:在初始化二级指针 ppi 时,不能直接 ppi = &&i,因为&i 获取的是一个具体的数值,而具体数字是没有指针的。

    (2)指针数组

    指针变量和普通变量一样,也能组成数组,指针数组的具体定义如下:

    数据类型 *数组名[指针数组长度];
    

    下面举一个简单的例子熟悉指针数组:

    //定义一个数组
    int nums[5] = {2, 3, 4, 5, 2}, i;
    
    //定义一个指针数组
    int *p[5];
    
    //定义一个二级指针
    int **pp;
    
    //循环给指针数组赋值
    for(i = 0; i < 5; i++){
    	p[i] = &nums[i];
    }
    
    //将指针数组的首地址赋值给 pp,数组 p 的数组名作为 p 的首地址,也作为 p 中第一个元素的地址。
    //数组存放的内容为普通变量,则数组名为变量的指针;数组存放的内容为指针,则数组名为指针的指针。
    pp = p;
    
    //利用二级指针 pp 输出数组元素
    for(i = 0; i < 5; i++){
    	//pp == &p[0] == &&nums[0],nums[0] == *p[0] == **pp
    	printf("%d", **pp);
    	
    	//指针变量+整数的操作,即移动指针至下一个单元
    	pp++;
    }
    

    3.4、指针与多维数组

    讲多维数组是个麻烦的事,因为多维数组和二维数组没有本质的区别,但是复杂度倒是高了许多。这里我主要还是用二维数组来举例,但是还是会给大家分析多维数组和指针的关系。

    (1)多维数组的地址

    先用一个简单的数组来举例:

    int nums[2][2] = {
    	{1, 2},
    	{2, 3}
    };
    

    我们可以从两个维度来分析:

    1. 先是第一个维度,将数组当成一种数据类型 x,那么二维数组就可以当成一个元素为 x 的一维数组。
    2. 如上面的例子,将数组看成数据类型 x,那么 nums 就有两个元素。nums[0]和 nums[1]。
    3. 我们取 nums[0]分析。将 nums[0]看做一个整体,作为一个名称可以用 x1 替换。则 x1[0]就是 nums[0][0],其值为 1。
      在这里插入图片描述

    我们知道数组名即为数组首地址,上面的二维数组有两个维度。首先我们把按照上面 1 来理解,那么 nums 就是一个数组,则nums 就作为这个数组的首地址。第二个维度还是取 nums[0],我们把 nums[0]作为一个名称,其中有两个元素。我们可以尝试以下语句:

    printf("%d", nums[0]);
    

    此语句的输出结果为一个指针,在实验过后,发现就是 nums[0][0]的地址。即数组第一个元素的地址。

    如果再多一个维度,我们可以把二维数组看做一种数据类型 y,而三维数组就是一个变量为 y 的一维数组。而数组的地址我们要先确定是在哪个维度,再将数组某些维度看成一个整体,作为名称,此名称就是该维度的地址(这里有些绕)。

    例:

    //假设已初始化,二维数组数据类型设为 x,一维数组数据类型设为 y
    int nums[2][2][2];
    
    //此数组首地址为该数组名称
    printf("此数组首地址为%d", nums);
    
    //此数组可以看做存储了两个 x 类型元素的一维数组,则 nums[0] = x1 的地址为
    printf("第二个维度的首地址为%d", nums[0]);
    
    //而 x1 可以看做存储了两个 y 类型元素的一维数组,则 y1 = x1[0] = nums[0][0]
    printf("第三个维度的首地址为%d", nums[0][0]);
    
    

    三维数组实际存储形式如下:
    在这里插入图片描述
    实际存储内容的为最内层维度,且为连续的。对于 a 来说,其个跨度为 4 个单元;对 a[0]来说,其跨度为 2 个单元;对 a[0][0]来说,跨度为一个单元。有上面还可以得出:

    a == a[0] == a[0][0] == &a[0][0][0];
    

    上面的等式只是数值上相等,性质不同。

    (2)多维数组的指针

    在学习指针与数组的时候,我们可以如下表示一个数组:

    int nums[5] = {2, 4, 5, 6, 7};
    int *p = nums;
    

    在前面讲指针数组时,所有指针数组元素都指向一个数字,那么我们现在可以尝试用指针数组的每个元素指向一个数组:

    //定义一个二维数组
    int nums[2][2] = {
    	{1, 2},
    	{2, 3}
    };
    
    //此时 nums[0]、和 nums[1]各为一个数组
    int *p[2] = {nums[0], nums[1]};
    
    //我们可以用指针数组 p 操作一个二维数组
    
    //p 为数组 p 的首地址,p[0] = nums[0] = *p,**p = nums[0][0]
    printf("nums[0][0] = %d", **p);
    
    //指针 + 整数形式,p+1 移动到 nums 的地址,*(p +1) = nums[1],则**(p + 1) = nums[1][0]
    printf("nums[1][0] = %d", **(p + 1));
    
    //先*p = nums[0],再*p + 1 = &nums[0][1],最后获取内容*(*p + 1)即为 nums[0][1]
    printf("nums[0][1] = %d", *(*p + 1));
    

    这里可能不能理解为什么*p + 1 = &nums[0][1],而不是 nums[1]。*p 获得的是一个一维数组,而 int 数组 + 1 的跨度只有 4 个字节,也就是一个单元。前面 p 是一维数组的指针,其跨度为一个数组。所以*p + 1 = &nums[0][1],而 p + 1 = nums[1]。

    四、指针与函数

    前面学习函数学到,函数参数可以为 int、char、float 等,但是在操作时,这些参数只作为形参,所有操作都只在函数体内有效(除对指针的操作外),那么今天来学习一下指针作为函数参数。

    4.1、函数参数为指针

    我们直接做一个练习,定义一个函数,用来交换两个变量的内容。

    void swap(int *x, int *y);
    void main(){
    	int x = 20, y = 10;
    	swap(&x, &y);
    	printf("x = %d, y = %d", x ,y);
    }
    void swap(int *x, int *y){
    	int t;
    	t = *x;
    	*x = *y;
    	*y = t;
    }
    

    代码非常简单,我也就不细讲了。这里传入的参数为指针,所以调用 swap 方法后 x,y 的内容发生了交换。如果直接传入 x,y,那么交换只在 swap 中有效,在 main 中并没有交换。

    4.2、函数的返回值为指针

    返回值为指针的函数声明如下:

    数据类型 *函数名(参数列表){
    	函数体
    }
    //例如:
    int s;
    int *sum(int x, int y){
    	s = x + y;
    	return &s;
    }
    

    在函数调用前要声明需要对函数声明(有点编译器不需要)

    int s;
    void mian(){
    	int *r = sum(10, 9);
    	printf("10 + 9 + %d", *r);
    }
    int *sum(int x, int y){
    	s = x + y;
    	return &s;
    }
    

    除了上面的操作,更实用的是返回一个指向数组的指针,这样就实现了返回值为数组。

    4.3、指向函数的指针

    C 语言中,函数不能嵌套定义,也不能将函数作为参数传递。但是函数有个特性,即函数名为该函数的入口地址。我们可以定义一个指针指向该地址,将指针作为参数传递。

    函数指针定义如下:

    数据类型 (*函数指针名)();
    

    函数指针在进行“*”操作时,可以理解为执行该函数。函数指针不同与数据指针,不能进行+整数操作。

    下面举个例子,来使用函数指针:

    #include <string.h>
    /**
    *	定义一个方法,传入两个字符串和一个函数指针 p,用 p 对两个字符串进行操作
    */
    void check(char *x, char *y, int (*p)());
    void main(){
    	//string.h 库中的函数,使用之前需要声明该函数。字符串比较函数
    	int strcmp();
    	char x[] = "Zack";
    	char y[] = "Rudy";
    	
    	//定义一个函数指针
    	int (*p)() = strcmp;
    
    	check(x, y, p);
    }
    void check(char *x, char *y, int (*p)()){
    	if(!(*p)(x, y)){
    		printf("相等");
    	}else{
    		printf("不相等");
    	}
    }
    

    利用函数指针调用方法具体操作如下:

    (*p)(x, y);
    

    指针除了这些地方,还在结构体中用处巨大。今天就先讲到这里~·

    展开全文
  • C语言指针描述(一篇全部透C指针)

    万次阅读 多人点赞 2018-08-11 23:10:40
    C语言 指针语法 #include<stdio.h> #include<stdlib.h> main(){ int a=10; int* pointer=&a; } C语言里面的指针只能操作地址 指针赋值给变量 int a = 10; int* pointer = &a...

    C语言  指针语法

    	#include<stdio.h>
    	#include<stdlib.h>
    	main(){
    		int a=10;
    		int* pointer=&a;	
    	}

    C语言里面的指针只能操作地址  

     

    指针赋值给变量

    int a = 10;
    int* pointer = &a;//吧地址赋值给指针  指针本身是存储地址的
    int b = *pointer;
    • 指针 int i = 123; int* pointer = &i;

    • pointer 取到的是i的地址

    • *pointer 取到的是i的值

    •   &pointer 取出pointer自己的地址

    • 野指针 指针赋值操作之前要先初始化 给指针变量赋一个程序中声明的变量的地址

    • int* 指向int类型变量的地址

    • 值传递和引用传递 都是传递的值 但是引用传递传递的是地址值 子函数修改main函数的变量的值 一定要用引用传递

    • 指针和数组的关系 数组就是连续的内存空间 拿到数组的首地址 就可以对数组的每一个元素进行操作 通过指针的位移运算 位移运算 指针变量+1移动的字节数跟指针的类型有关

    • 指针的长度 32位操作系统4个字节 64位 8字节

    利用指针返回多个值      :  在C语言里面方法是不能返回数组的如果使用返回多个值可以通过指针改变该地址内容

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    "*" 的几个含义   int*  声明一个int类型的指针变量
                x * y  乘法运算
                int* pointer;
                *pointer; 取出指针变量pointer 中保存的内存地址对应的内存中的值 
    */
    main(){    
          int i =1;
          int j = 2;
          //char c;
          function(&i,&j);
          printf("i = %d,j = %d\n",i,j);
           system("pause"); 
           } 
     function(int* pointer, int* pointer2){
         *pointer *= 2;
         *pointer2 *=2;
        }

    数组与指针的干系

    #include<stdio.h>
    #include<stdlib.h>
    /**
    数组实际上就是一块连续的内存空间 
    */
    main(){
    	char array[]={'a','b','c','d'}; 
    	//int array[]={1,2,3,4};
    	printf("array[0]=%#x\n",&array[0]);
    	printf("array[1]=%#x\n",&array[1]);
    	printf("array[2]=%#x\n",&array[2]);
    	printf("array[3]=%#x\n",&array[3]);
    	//数组变量名的地址实际上是第一个元素的地址
    	char* pointer = &array;//表示吧数组地址付指针   数组每个单位多有一个独立的地址 
    	//在数组于指针里面    如这个*(pointer+0)  要开位数   如char  是 1 位 可以加一  如果是int 是4位 没有任何用 
    	printf("*(pointer+0) = %c\n",*(pointer+0));
    	printf("*(pointer+1) = %c\n",*(pointer+1));
    	printf("*(pointer+2) = %c\n",*(pointer+2));
    	printf("*(pointer+3) = %c\n",*(pointer+3));
    	
    } 

    多级指针

    多级指针 数星星  有几个星就是几级指针 取值通过三级指针拿到最初的变量的值 ***point3 

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    多级指针 数星星  有几个星就是几级指针 取值通过三级指针拿到最初的变量的值 ***point3 
    */
    main(){    
          int i = 123;
          //int类型的一级指针 
          int* pointer = &i;
          //int类型的二级指针 二级指针只能保存一级指针的地址 
          int** pointer2 = &pointer; 
          //int类型的三级指针   三级指针只能存二级指针
          int*** pointer3 = &pointer2; 
          printf("***pointer3 = %d\n",***pointer3);
           system("pause"); 
           } 
    

     

    C语言结构体

    c语言结构体就是java里面 的对象类差不多下面看看例子

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    c结构体 类似java的class  struct来声明c的结构体 
    结构体的大小大于等于结构体中每一变量的占字节数的和
     结构体的大小是最大的那个变量所占字节数的整数倍 
     C结构体中不能定义函数  
     
     函数指针的定义   返回值(*函数指针变量名字)(返回值); 
     -> 间接引用运算符   
    */
    void study(){
               printf("good good study!\n");
               }
     struct Student{
          int age;  //8
          int score;  // 4
          char sex;   //1
          void(*studypointer)();// 函数指针的定义 
          };
    main(){    
     stud stu = {18,100,'f'};
     stu.studypointer = &study;
     stu.studypointer();//调用结构体里面的方法
     struct Student* stuPointer = &stu;//结构体指针使用
     printf("*stuPointer.age = %d\n",(*stuPointer).age);
     (*stuPointer).sex ='m';//改变结构体的值
     printf("stu.sex = %c\n",stu.sex);
     printf("stuPointer->age = %d",stuPointer->age);//stuPointer->age 间接引用运算符   
     //printf("stu.age = %hd\n",stu.age);
     //printf("stu.score = %d\n",stu.score);
     //printf("stu.sex = %c\n",stu.sex);
    // printf("结构体student占%d个字节\n",sizeof(stu));
           system("pause"); 
           } 
    

    C语言的联合体

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    联合体占字节数取决于 其中成员 占内存空间最大的那一个 
    也称为共用体  一般用于内存比较小的机器  
    */
    union u{
          int num; //4
          double d; //8
          }
    main(){    
       union u u1;
       u1.num = 123;
       u1.d = 123.456;
       printf("union占%d个字节\n",sizeof(u1));
       printf("u1.num = %d\n",u1.num); //
           system("pause"); 
           } 
    

    C语言枚举

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    */
    enum weekday{
         MON=9, TUE, WEND,THUR,FRI,SAT,SUN
         };
    main(){    
       enum weekday day = MONe;
       printf("day= %d",day);
           system("pause"); 
           } 
    

    #define MON  1
    #define TUE   2
    #define WED  3
    #define THU   4
    #define FRI    5
    #define SAT   6
    #define SUN   7

    (1) 枚举型是一个集合,集合中的元素(枚举成员)是一些命名的整型常量,元素之间用逗号,隔开。

    (2) DAY是一个标识符,可以看成这个集合的名字,是一个可选项,即是可有可无的项。

    (3) 第一个枚举成员的默认值为整型的0,后续枚举成员的值在前一个成员上加1。

    (4) 可以人为设定枚举成员的值,从而自定义某个范围内的整数。

    (5) 枚举型是预处理指令#define的替代。

    (6) 类型定义以分号;结束。

     

    2. 使用枚举类型对变量进行声明

    新的数据类型定义完成后,它就可以使用了。我们已经见过最基本的数据类型,如:整型int, 单精度浮点型float, 双精度浮点型double, 字符型char, 短整型short等等。用这些基本数据类型声明变量通常是这样:

     

    char     a; //变量a的类型均为字符型char
    char     letter;
    int        x,
               y,
               z; //变量x,y和z的类型均为整型int
    int       number;
    double  m, n;
    double  result; //变量result的类型为双精度浮点型double

     

     

    既然枚举也是一种数据类型,那么它和基本数据类型一样也可以对变量进行声明。

    方法一:枚举类型的定义和变量的声明分开

    enum DAY
    {
          MON=1, TUE, WED, THU, FRI, SAT, SUN
    };
    
    
    
    enum DAY yesterday;
    enum DAY today;
    enum DAY tomorrow; //变量tomorrow的类型为枚举型enum DAY
    enum DAY good_day, bad_day; //变量good_day和bad_day的类型均为枚举型enum DAY

     

    方法二:类型定义与变量声明同时进行:

    
    enum //跟第一个定义不同的是,此处的标号DAY省略,这是允许的。
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday; //变量workday的类型为枚举型enum DAYenum //跟第一个定义不
    
    
    
    enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days; //变量days的类型为枚举型enum week
    
    
    
    enum BOOLEAN { false, true } end_flag, match_flag; //定义枚举类型并声明了两个枚举型变量

    方法三:用typedef关键字将枚举类型定义成别名,并利用该别名进行变量声明:

     

    typedef enum workday
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday; //此处的workday为枚举型enum workday的别名
    
    
    
    workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday,也即enum workday
    
    
    
    enum workday中的workday可以省略:
    
    typedef enum
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    } workday; //此处的workday为枚举型enum workday的别名
    
    workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday,也即enum workday

     

     

    也可以用这种方式:

     

    typedef enum workday
    {
        saturday,
        sunday = 0,
        monday,
        tuesday,
        wednesday,
        thursday,
        friday
    };
    


    workday today, tomorrow; //变量today和tomorrow的类型为枚举型workday,也即enum workday

    注意:同一个程序中不能定义同名的枚举类型,不同的枚举类型中也不能存在同名的命名常量。错误示例如下所示:

     

     

     

    C语言自定义类型

    C语言自定义类型就是取别名

    #include<stdio.h>    
    #include<stdlib.h>    
    /**
    */
    typedef int i;
    main(){    
               i j = 123;
               printf("j = %d\n",j);
           system("pause"); 
           } 
    

     

    展开全文
  • C语言指针

    千次阅读 多人点赞 2018-03-30 22:19:08
    c语言指针学习指针只有两层含义,1:指向地址,2:指针有类型,类型是其指向的内存空间数据的类型,表示从首地址开始取多少字节。C语言相比于其他高级语言,不仅是运行速度快,而且还能够直接操作硬件,操作硬件就是...
    c语言指针学习
    指针只有两层含义,1:指向地址,2:指针有类型,类型是其指向的内存空间数据的类型,表示从首地址开始取多少字节。

    C语言相比于其他高级语言,不仅是运行速度快,而且还能够直接操作硬件,操作硬件就是依靠C语言指针这一强大功能实现的,学会C语言指针,就好像是武林高手打通了任督二脉,能大幅度提升编程能力。

    地址是个什么东西:计算机存储的数据都有一个唯一的地址,32位系统就是8位16进制数表示的。比如0x12345678就是计算机的一个地址。一位十六进制代表四位二进制,0x12345678转换成二进制就是0001-0010-0011-0100-0101-0110-0111- 1000而每八位二进制占一个字节。


    int *(*p(int))【3】   
    1. p与()结合(考虑优先级)      p是一个函数
    2. p(int)                                    函数有一个 整形变量
    3. *p(int)                                      函数返回值类型为指针
    4. *p(int)【3】                          指针指向一个数组
    5. *(*p(int))【3】                  数组里的元素都是指针
    6. int *(*p(int))【3】            指针指向的内容是int

    从最简单的指针再来理解一下
    int i=123
    int *p=&i
    上面的意思是pint *类型的指针,指向i的地址,指针类型代表从首地址开始取多少个类型字节的数据。

    int **ptr2    指向指针的指针,如果int*ptr1=&a,则*ptr1=a,*ptr2=ptr1,**ptr2=a。


    下面的两个函数,只有指针操作的swap函数2才能实现两个数的交换,第一个代码的swap函数只是在自己的函数空间里操作!并没有影响到主函数!
    void swap(int a,int b)
    {
        int tmp;
        tmp=a;
        a=b;
        b=tmp;
    }
    int main (void)
    {
      int a=10;
      int b=20;
      printf("a=%d b=%d\n",a,b);
      
      swap(a,b);
      
      printf("a=%d b=%d\n",a,b);
    }

    #include <stdio.h>
    void swap(int *,int *);
    void swap(int *p1,int *p2)
    {
    int tmp;
    tmp=*p1;
    *p1=*p2;
    *p2=tmp;
    }
    int main(void)
    {
    int a=10;
    int b=20;
    printf("a=%d b=%d\n",a,b);
    swap(&a,&b);
    printf("a=%d b=%d\n",a,b);
    }
    展开全文
  • C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言指针教程C语言...
  • 死磕C语言指针

    万次阅读 多人点赞 2019-11-01 09:05:30
    兜兜转转还是逃不过 C 语言,这该死的缘分。 先看一眼我的西野七濑 学习自:https://zhuanlan.zhihu.com/p/89121683 目录 1 指针 1.1 指针是乜嘢 1.2 指针的声明 1.3 运算符 1.4简单的小例子们: 例子1 ...

    兜兜转转还是逃不过 C 语言,这该死的缘分。

    先看一眼我的西野七濑

    学习自:https://zhuanlan.zhihu.com/p/89121683

    目录

    1 指针

    1.1 指针是乜嘢

    1.2 指针的声明

    1.3 运算符

    1.4 简单的小例子们:

    例子1 

    例子2:指针在函数间通信

    1.5 指针的运算

    1.5.1 指针加减运算

    1.5.2 间址运算

    1.5.3 指针的相减 = 两个地址之间的偏移量

    2 指针与数组

    2.1 指针和一维数组

    2.1.1 定义数组及指针变量

    2.1.2 能动手就不要瞎扯

    2.2 指针和二维数组

    2.2.1 定义

    2.2.2 能动手就不要瞎扯

    3 指针数组

    3.1 定义

    3.2 灵活的双手动起来

    4 多级指针

    5 字符指针与字符串

    5.1 定义

    5.2 打代码

    6 指针型函数

    6.1 定义

    6.2 敲代码

    7 指向函数的指针

    7.1 定义

    7.2 码代码

    8 结构体指针

    8.1 结构体变量指针

    8.1.1 定义

    8.1.2 干活

    8.2 结构体数组指针

    8.2.1 定义

    8.2.2 搬砖


    1 指针

    1.1 指针是乜嘢

    指针(pointer):一个值为内存地址的变量。

    char 类型变量的值是字符,int 类型变量的值是整数,指针变量的值是地址。

    1.2 指针的声明

    数据类型 *指针名,这里的 * 表明声明的变量是一个指针,没有访问指针目标的含义。

    int * pi; // pi是指向int类型变量的指针
    char * pc; // pc是指向char类型变量的指针
    float * pf; // pf是指向float类型变量的指针

    指针存放的值是一个地址,在大部分系统内部,该地址由一个无符号整数表示,但不能把指针认为是整数类型。

    • 指针变量不能赋予常量值
    • 不能接受键盘输入的数据

    1.3 运算符

    间接运算符 *:访问地址的目标

    val = *ptr; // 找出ptr指向的值

    地址 & 运算符:取变量的存储地址

    &num 表示变量 num 的地址。

    1.4 简单的小例子们:

    例子1 

    #include <stdio.h>
     
    int main ()
    {
       int  num = 97;   
       int  *p;        // 指针变量的声明 
       p = &num;       //在指针变量中存储 num 的地址 
    
       printf("Address of var variable: %p\n", &num );
       // 指针变量中存储的地址 
       printf("Address stored in ip variable: %p\n", p );
       // 使用指针访问值 
       printf("Value of *ip variable: %d\n", *p );
       return 0;
    }

    结果:

    图解

    例子2:指针在函数间通信

    #include<stdio.h>
    
    void interchange(int *u, int *v);
    
    int main(){
    	int x = 5, y = 10;
    	printf("Originally x = %d and y = %d.\n", x,y);
    	
    	interchange(&x, &y);
    	printf("Now x = %d and y = %d.\n", x,y);
    	
    	return 0;
    }
    
    void interchange(int *u, int *v){// 参数为指针,函数传递的是地址 ,u与v存的是地址 
    	int temp;
    	temp = *u; // 直接改变对应地址存放的值 
    	*u= *v;
    	*v= temp; 
    }

    结果:

    1.5 指针的运算

    知识点:

    • 三个操作符的优先级:() > [] > *,没错 * 是最卑微的
    • *p++ 里,* 号和 ++ 属于同一优先级,且方向都是从右向左的,*p++ 和 *(p++) 作用相同

    1.5.1 指针加减运算

    #include<stdio.h>
    
    void main(){
    	int a=10,b=20,c=30;
    	int *p=&b;
    	printf("%p\n",&a);
    	printf("%p\n",&b);
    	printf("%p\n",&c);
    	p=p+1;
    	printf("%p\n",p);
    	p=p-2;
    	printf("%p\n",p);	
    } 

    结果:

    1.5.2 间址运算

    *p++:* 与 ++ 同优先级,结合方向为自右向左,p++,先赋值再自加,因此结果等价于 *p 返回其值,p++

    *++p:++p,先自加后赋值,等价于 p++, *p 返回其值

    (*p)++:括号优先,等价于 *p 返回其值,然后将 *p 的结果 + 1

    例:

    #include<stdio.h>
    
    int main(){
    	int a[] = {10,20,30}, *p=a; 
    	printf("*p++ is %d\n", *p++);   
    	p=a; 
    	printf("*++p is %d\n", *++p); 
    	p=a; 
    	printf("++(*p) is %d\n", ++(*p)); 
    	p=a;
    	printf("a[0] is %d\n",a[0]);
    	printf("(*p)++ is %d\n", (*p)++); 
    	return 0;
    }

    结果:

    1.5.3 指针的相减 = 两个地址之间的偏移量

    2 指针与数组

    2.1 指针和一维数组

    2.1.1 定义数组及指针变量

    数组名 s 代表的是该数组首元素的首地址,&s 代表的是整个数组的首地址

    s == &s[0],返回 ture

    &s == &s[0], 是错误的比较,尽管 &s 与 &s[0] 的地址值相同,但两者的含义不同

    2.1.2 能动手就不要瞎扯

    移动指向数组的指针

    数组元素的引用方法:

    因为 ps 是变量,s 是符号常量,不能给 s 赋值, s = p(×)

    例子:

    #include<stdio.h>
    
    int main(){
    	int i;
    	int a[5] = {1,2,3,4,5}, *p = a;   // p作为一维数组 a 的指针
    	// 通过 a[i] 方式输出所有元素
    	for(i=0; i<5; i++){
    		printf("%d ",a[i]);
    	} 
    	printf("\n");
    	// 通过 *(a+i)方式输出所有元素
    	for(i=0; i<5; i++){
    		printf("%d ",*(a+i));
    	}
    	printf("\n");
    	// 通过 *(p+i)方式输出所有元素,p不移动 
    	for(i=0; i<5; i++){
    		printf("%d ",*(p+i));
    	}
    	printf("\n");
    	printf("a is %p\n", a);
    	printf("p is %p\n", p);
    	// 通过 *p方式输出所有元素,p移动 
    	for(i=0; i<5; i++){
    		printf("%d ",*p++);
    	}
    	printf("\n");
    	printf("%p", p);
    }

    结果:

    2.2 指针和二维数组

    参考:C/C++二维数组总结

    2.2.1 定义

    (1) 二维数组定义

    定义了一个Array[3][4],那就指的是定义了一个三行四列的矩阵形状的二维数组,如下图所示。这样的矩阵在内存中是以箭头右边的方式存放的,也就是说实际上我们定义的二维数组在内存中仍然像是一维数组那样连续存储的。可以想象为把一个矩阵一层层伸展铺平。

    int array[3][4];   // 内含 int 数组的数组

    数组名 array 是该数组首元素的地址,一维数组首元素的地址,而 array[0] 本身是一个内含 4 个整数的数组,

    array = &array[0]。

    &array 是整个数组的首地址。

    array,&array,&array[0],&array[0][0],虽然地址值相同,但有各自的含义。

    例子:

    #include<stdio.h>
    
    int main(){
    	
    	int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    	
    	printf("array is %d\n",array);
    	printf("*array is %d\n",*array);
    	printf("array[0] is %d\n",array[0]);
    	printf("*array[0] is %d\n",*array[0]);
    	printf("array[0][0] is %d\n",array[0][0]);
    	printf("&array[0][0] is %d\n",&array[0][0]);
    }

    结果:

    (2) 二维数组指针定义

    基类型 (*指针变量)[整形表达式]

    int a[2][3], (*p)[3]  = a;

    () 优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是 n,也可以说是 p 的步长。执行 p+1 时,p 要跨过 n 个整型数据的长度。

    p[i]:指向 a[i] 的元素

    p++:指向数组 a 的后一个一维数组元素

    p--:指向数组 a 的前一个一维数组元素

    p+1:等价于 a+1

    当 p 指向 a 数组的开头时,可以通过以下形式来引用 a[i][j]

    *(p[i]+j):对应于 *(a[i]+j)

    *(*(p+i)+j):对应于 *(*(a+i)+j)

    *(*(p+i))[j]:对应于 *(*(a+i)+j)

    p[i][j]:对应于 a[i][j]

    数组指针 p 与对应的二维数组 a 的区别是:二维数组 a 是一个常量,数组指针 p 是一个变量

    2.2.2 能动手就不要瞎扯

    #include<stdio.h>
    
    void main(){
    	int i, j;
    	int a[2][3] = {{1,2,3},{4,5,6}}, (*p)[3] = a;
    	
    	// 通过 a[i][j] 方式输出所有元素 
    	for(i=0; i<2; i++)
    		for(j=0; j<3; j++)
    	printf("%d ",a[i][j]);	
    	printf("\n");	
    	
    	// 通过 *(*(a+i)+j) 方式输出所有元素 
    	for(i=0; i<2; i++)
    		for(j=0; j<3; j++)
    	printf("%d ",*(*(a+i)+j));	
    	printf("\n");
    	
    	// 通过 *(p[i]+j) 方式输出所有元素 
    	for(i=0; i<2; i++)
    		for(j=0; j<3; j++)
    	printf("%d ",*(p[i]+j));	
    	printf("\n");
    	
    	// 通过 *(*(p+i)+j) 方式输出所有元素 
    	for(i=0; i<2; i++)
    		for(j=0; j<3; j++)
    	printf("%d ",*(*(p+i)+j));	
    	printf("\n");
    				
    }

    3 指针数组

    3.1 定义

    存储指针的数组。它的每个元素都是指针变量,指向相同的数据类型。

    数组类型 *指针数组名[元素个数];

    int *p[3]; 

    [] 比 * 的优先级高,p 先与 [3] 结合,形成 p[3] 的数组形式,它有 3 个元素,然年再与 * 结合,表示是指针类型的数组。

    int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]

    使用指针数组更方便地操作长短不一的字符串,而使用二维数组来操作字符串相对浪费空间,如下:

    3.2 灵活的双手动起来

    例子

    #include <stdio.h>
     
    const int MAX = 3;
     
    int main ()
    {
       const char *words[] = {"wyd","is","smart"};
       
       int i = 0;
       for ( i = 0; i < MAX; i++)
       {
          printf("Value of words[%d] = %s\n", i, words[i] );
       }
       return 0;
    }

    4 多级指针

    二级指针:就是对一级指针再取地址

    三级指针:就是对二级指针再取地址

    #include <stdio.h>
     
    const int MAX = 3;
     
    void main ()
    {
       int *p, **pp, ***ppp, s = 100;
    
       p = &s;
       // q 存 p 的地址,p 存 s 的地址
       pp = &p;
       ppp = &pp;
       
       printf("Value of p = %d\n", *p); 
       printf("Value of pp = %d\n", **pp);
       printf("Value of ppp = %d\n", ***ppp);
       
    }

    结果

    5 字符指针与字符串

    5.1 定义

    指向 char 型数据的指针

    5.2 打代码

    #include <stdio.h>
     
    void main ()
    {
    	char s [] = "wyd is smart";
    	char *p = "wyd is handsome";
    	
    	*(s+3) = 0; // 在第4个字符位置加结束标志
    	puts(s); 
    	puts(p);
    	//*(p+3)=0; 运行报错,字符串常量不能赋值 
    	p=s;   // 没有这行,下面输入字符回车会报错 
    	printf("%p",p); 
    	gets(p);
    	puts(p);
    }

    6 指针型函数

    6.1 定义

    函数返回值的数据类型决定了该函数的数据类型。

    数值型函数:返回值为数值类型

    字符型函数:返回值为字符类型

    指针型函数:返回值是地址

    数据类型 *函数名(参数)

    如:int *func(int x,float y)

    6.2 敲代码

    例 1

    #include <stdio.h>
     
    int *f(int *x, int *y){// x与y都是指针变量,存的地址
        if(*x < *y)
            return x;
        else
            return y;
    }
     
    void main ()
    {
        int x=7, y=8, *p;
        p=f(&x, &y);
        printf("%p\n", p);
        printf("%d\n", *p);
    }
    

    结果:

    例 2

    #include <stdio.h>
     
    int *f(char *b){
    	b += 3;
    	return b;
    }
    
    void main ()
    {
    	char a[] = "abcdefg", *p;
    	p = f(a);
    	printf("%s\n",p);
    }

    结果

    7 函数指针(指向函数)

    7.1 定义

     C 语言中,指针变量除了保存数据的存储地址外,还可以保存函数的存储首地址。函数的存储首地址又称为函数的执行入口地址。

    数据类型 (*函数指针名)();

    如:int (*func)();                                                                                                                                                                                                   

    7.2 码代码

    #include <stdio.h>
     
    int f1(int x){
    	return x*x;
    }
    int f2(int x){
    	return x*x*x;
    }
    // f1 和 f2 形参均为函数指针,存放函数的首地址
    int f(int (*f1)(), int (*f2)(), int x){ 
    	return f2(x) - f1(x);
    }
    void main(){
    	int i;
    	i = f(f1, f2, 2);
    	printf("%d\n",i);
    }
    

      结果: 4                              

    8 结构体指针

    8.1 结构体变量指针

    8.1.1 定义

    指向结构体变量的指针。

    struct 结构体类型名 *结构体指针名;
     
    struct Student st,*p = &st; // p 是指向结构体变量 st 首地址的指针
    • p 不是结构体变量,不能写成 p.age,要写成(*p).age,或 p -> age
    • -> 的优先级最高,如:p->age+1,相当于(p->age)+1,即返回 p->age 的值+1

    8.1.2 干活

    #include<stdio.h> 
     
    struct Student{
    	int no;
    	char name[20];
    }st={101,"apple"},*p;
     
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",st.no,st.name);
    	printf("num=%d,name=%s\n",(*p).no,(*p).name);
    	printf("num=%d,name=%s\n",p->no,p->name);
    }

    结果:

    8.2 结构体数组指针

    8.2.1 定义

    指向结构体数组,即将该数组的起始地址赋值给该指针变量。

    struct Student  s[40], *p=s;

    8.2.2 搬砖

    (1)第一回合

    #include<stdio.h> 
     
    struct Student{
    	int no;
    	char name[20];
    }st[2]={{101,"apple"},{102,"peach"}}, *p;
     
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",p->no,p->name);
    	printf("num=%d,name=%s\n",(p++)->no,p->name); // 先取得p->no的值,再进行p自增1,指向下一个元素st[1] 
    	printf("num=%d,name=%s\n",p->no,p->name);
    }

    结果:

    (2)第二回合

    #include<stdio.h> 
     
    struct Student{
    	int no;
    	char name[20];
    }st[2]={{101,"apple"},{102,"peach"}}, *p;
     
    int main(){
    	p = &st;
    	printf("num=%d,name=%s\n",p->no,p->name);
    	printf("num=%d,name=%s\n",(++p)->no,p->name); // 先进行p自增1,指向下一个元素st[1] ,再取成员 no 的值 
    }

    结果:

     

    展开全文
  • c语言指针

    千次阅读 2019-03-31 22:06:54
    //1什么是指针?2指针的数据类型形式?3指针的占几个字节?...//1答:指针指针变量,在c语言中专门存储系统分配的内存地址,我们可以通过这个地址找到 //内存分配的空间,从而进行对变量进行操作。 //2答...
  • c语言指针课件

    2011-11-20 23:34:44
    c语言 指针 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件 c语言指针课件
  • c和指针》是c语言指针的高级教程,对于指针的讲解很深刻,很精!
  • C/C++】结合计算机组成原理看C语言指针

    千次阅读 多人点赞 2020-04-13 21:12:03
    先由一个问题引入,C语言指针占多少字节? 如果上过大一C语言课程,那你肯定脱口而出:4个字节。但是你可能忘了老师很早说的一个前提,在32位处理器(或操作系统/编译环境)中,才是这个答案。 实际上在64位...
  • C语言指针相关知识理解以及总结

    千次阅读 多人点赞 2017-07-17 09:05:31
    C语言指针相关知识理解以及总结,什么是指针,关于*和&,指针变量运算,C语言数组指针(指向数组的指针),C语言字符串指针,二级指针,C语言指针数组,C语言与二维数组,函数指针,指针总结
  • 所有学过C语言的人都知道,C语言难在它的指针的使用和理解,今天,我带给大家C语言指针的教程,供大家学习交流,如果有讲的不对的地方,请给作者邮箱留言(邮箱在底部)。 指针是什么?指针是指向某个变量、...
  • c语言指针示例 空指针 (NULL pointer) The word "NULL" is a constant in C language and its value is 0. In case with the pointers - if any pointer does not contain a valid memory address or any pointer is...
  • c语言指针++ C中的指针是什么? (What is Pointer in C?) A pointer is a variable that holds the address of another variable to which it points. We know that if a variable is defined, it allocates some ...
  •   C语言指针基础知识点(一)–指针及指针变量   C语言指针基础知识点(二)–指针变量的引用   C语言指针基础知识点(三)–指针变量作为函数参数   C语言指针基础知识点(四)–通过指针引用数组   C语言指针...
  • C语言指针总结

    2017-06-01 09:43:43
    C 指针
  • C语言指针知识点小结

    千次阅读 多人点赞 2020-01-10 15:40:06
      C语言指针基础知识点(一)–指针及指针变量   C语言指针基础知识点(二)–指针变量的引用   C语言指针基础知识点(三)–指针变量作为函数参数   C语言指针基础知识点(四)–通过指针引用数组   C语言指针...
  • 理解C语言指针

    千次阅读 2019-03-25 14:40:45
    C语言指针理解 本人在初学的时候认为c语言中指针很好理解,但身边好多同学一直在说老师讲的指针太抽象了,看不到,摸不着,非常难理解,甚至学了4年计算机,毕业了,不少同学还说不清楚指针是什么,遇到指针的问题...
  • c语言指针比较辨析

    万次阅读 2020-04-13 09:29:13
    c语言指针比较辨析 如题。 指针比较只对相同对象才有意义:如果两个指针指向同一个简单对象,则相等;如果指针指向同一个结构的不同成员,则指向结构中后声明的成员的指针较大;如果指针指向同一个联合的不同成 员,...
  • C语言指针数组介绍,定义指针数组,输入输出指针数组 1、什么是指针数组; (1)数组里面的每一个元素不是值而是值,而是指针。 (2)把很多的指针集合在一起,就是一个指针数组 2、定义一个指针数组: ***(p+1) ...
  • C语言指针详解

    千次阅读 多人点赞 2018-07-13 13:45:15
    前言这不是我第一次写关于C指针的文章了,只是因为指针对于C来说太重要,而且随着自己编程经历越多,对指针的理解越多,因此有了本文。然而,想要全面理解指针,除了要对C语言有熟练的掌握外,还要有计算机硬件以及...
  • C语言指针详解(经典,非常详细)

    万次阅读 多人点赞 2019-06-01 17:26:12
    要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,...
  • 对于C语言指针的理解

    千次阅读 多人点赞 2019-02-17 17:57:35
    对于C语言指针的理解 学习c语言中最难得部分就是指针了 指针是什么? 指针本身是一个变量,它存储的是数据在内存中的地址而不是数据本身的值。它的定义如下: 指针的形式: 类型 *变量名 比如int *p就是一个整型的...
  • C语言指针偏移

    2020-11-23 17:43:06
    C语言指针与自增自减运算符 1.定义一个数组和整形指针变量 int a[3]={2,7,8},*p; p=a;//将数组a的首地址赋给指针变量p 2.执行下面操作, (1)j=*p++; printf(“a[0]=%d,j=%d,*p=%d”,a[0],j,*p); 变量 值 a...
  • C语言指针详细讲C语言指针详细讲解解C语言指针详细讲解C语言指针详细讲解
  • 漫谈C语言指针入门

    万次阅读 多人点赞 2016-04-06 10:26:36
    别扯淡你一看C语言就懵逼,琢磨LOL英雄属性你挺6啊! 拓展: 有人一提到指针地址,就会一脸懵逼,因为在他们的脑海中,指针的概念始终建立不起来,总感觉自己跟指针之间隔着一层迷雾,那我现在就用1分钟的时间,...
  • 深入理解C语言指针类型

    千次阅读 多人点赞 2018-05-24 15:01:46
    C语言指针类型
  • 10-C语言指针-会指针才算学C

    千次阅读 多人点赞 2020-11-25 08:37:00
    指针的定义在程序当中,我们使用*表示指向。指针变量的定义为:指向单元的数据类型 *指针变量名;int *intPointer; // 指向int变量的指针intPointe...
  • c语言指针作为函数的参数

    万次阅读 多人点赞 2018-07-09 22:00:43
    c语言中实参和形参之间的数据传输是单向的“值传递”方式,也就是实参可以影响形参,而形参不能影响实参。指针变量作为参数也不例外,但是可以改变实参指针变量所指向的变量的值。 #include &lt;stdio.h&...
  • 指针C语言中一个重要的概念,也是c语言的重要角色。可以说指针c的精华所在,学习指针虽然不易,但是只要肯花上时间去反复的理解和实践,就一定可以很好的掌握它。 一、指针是什么 指针到底是什么?我们先举一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,268,023
精华内容 507,209
关键字:

c指针