精华内容
下载资源
问答
  • 变量的指针和指向变量的指针变量

    千次阅读 2020-04-24 20:53:08
    指针和指针变量的定义: 一变量的地址称为该变量的“指针” ...可以用赋值语句使一个指针变量得到另一变量的地址,从而使它指向一个该变量 例子 float *pointer_3; char *pointer_4; po...

    指针和指针变量的定义:

    一个变量的地址称为该变量的“指针”
    例如,地址1000是变量i的指针。如果有一个变量专门用来存放另一变量的地址(即指针),则它称为“指针变量”

    定义一个指针变量

    定义指针变量的一般形式为
    基类型 *指针变量名;
    说明
    可以用赋值语句使一个指针变量得到另一个变量的地址,从而使它指向一个该变量
    例子
    float *pointer_3;
    char *pointer_4;
    pointer_1=&i;
    pointer_2=&j;
    在这里插入图片描述
    注意

    1. 指针变量前面的“*”,表示该变量的类型为指针型变量
      例 : float pointer_1;
      指针变量名是pointer_1 ,而不是
      pointer_1
    2. 在定义指针变量时必须指定基类型。
      需要特别注意的是,只有整型变量的地址才能放到指向整型变量的指针变量中。下面的赋值是错误的∶
      float a;
      int * pointer_1;
      pointer_1=&a;

    指针变量的引用

    注意:
    指针变量中只能存放地址(指针)
    不要将一个整数(或任何其他非地址类型的数据)赋给一个指针变量
    例子 —— 通过指针变量访问整型变量

    #include <stdio.h>
    void main()
    {
         int a,b;
         int *pointer_1, *pointer_2;
         a=100;b=10;
         pointer_1=&a;  /*把变量a的地址赋给pointer_1 */  
         pointer_2=&b;  /*把变量b的地址赋给pointer_2 */
    printf(″%d,%d\n″,a,b);
    printf(″%d,%d\n″,*pointer_1, *pointer_2);
    }
    

    在这里插入图片描述

    对“&”和“*”运算符说明:

    如果已执行了语句 pointer_1=&a;

    1. &* pointer_1的含义是什么?
      “&”和“”两个运算符的优先级别相同,但按自右而左方向结合。因此,& pointer_1与&a相同,即变量a的地址。
      如果有pointer_2 =&* pointer_1 ;它的作用是将&a(a的地址)赋给pointer_2 ,如果pointer_2原来指向b,经过重新赋值后它已不再指向b了,而指向了a
      在这里插入图片描述
    2. &a的含义是什么?
      先进行&a运算,得a的地址,再进行
      运算。&a和pointer_1的作用是一样的,它们都等价于变量a。即*&a与a等价
    3. (*pointer_1)++相当于a++
      例子 —— 输入a和b两个整数,按先大后小的顺序输出a和b
    #include <stdio.h>
    void  main()
    { int *p1,*p2,*p,a,b;
      scanf("%d,%d",&a,&b);
     p1=&a;p2=&b;
      if(a<b)
     {p=p1;p1=p2;p2=p;}
     printf("a=%d,b=%d\n\n″,a,b);
      printf("max=%d,min=%d\n″,*1,*2);
    } 
    

    在这里插入图片描述

    指针变量作为函数参数

    例子 —— 对输入的两个整数按大小顺序输出

    #include <stdio.h>
    void main()
    {void swap(int *p1,int *p2);
     int a,b;
     int *pointer_1,*pointer_2;
        scanf("%d,%d",&a,&b);
     pointer_1=&a; pointer_2=&b;
      if(a<b=swap(pointer_1,pointer_2));
     printf("\n%d,%d\n",a,b);
    }   
    void swap(int *p1,int *p2)
    { int  temp;
          temp=*p1;
         *p1=*p2;
         *p2=temp;
    }
    

    在这里插入图片描述

    展开全文
  • 目录 、C 语言数组指针指向数组的指针) 二、C 语言字符串指针指向字符串的指针) 三、C 语言指针数组...① 定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 元素...

    目录

    一、C 语言数组指针(指向数组的指针)

    二、C 语言字符串指针(指向字符串的指针)

    三、C 语言指针数组(数组每个元素都是指针)

    四、二维数组指针(指向二维数组的指针)

    五、指针数组和二维数组指针的区别:

    六、常见指针变量的例子集合:见下图


    一、C 语言数组指针(指向数组的指针)

    定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。 在 C 语言中,我们将第 0 个元素的地址称为数组的首地址。 以上面的数组为例,下图是 arr 的指向:

    #include <stdio.h>
    int main(){
    int arr[] = { 99, 15, 100, 888, 252 };
    int len = sizeof(arr) / sizeof(int); //求数组长度
    int i;
    for(i=0; i<len; i++){
    printf("%d ", *(arr+i) ); //*(arr+i)等价于arr[i]
    }
    printf("\n");
    return 0;
    }
    
    运行结果:
    99 15 100 888 252

    ② 定义一个指向数组的指针:

    int arr[] = { 99, 15, 100, 888, 252 };
    int *p = arr;

           arr 本身就是一个指针,可以直接赋值给指针变量 p。 arr 是数组第 0 个元素的地址,所以 int *p = arr;也可以写作int *p = &arr[0];。也就是说, arr、 p、 &arr[0] 这三种写法都是等价的,它们都指向数组第 0 个元素,或者说指向数组的开头。
    ③ 两种方案来访问数组元素:
    1) 使用下标
    也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针,那么也可以使用 p[i] 来访问数组元素,它等价于 arr[i]。
    2) 使用指针
    也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针,也可以使用 *(arr+i) 来访问数组元素,它等价于 *(p+i)。

    ④ 关于数组指针的谜题:

    *和++优先级(一样,从右往左)

    假设 p 是指向数组 arr 中第 n 个元素的指针,那么 *p++、 *++p、 (*p)++ 分别是什么意思呢?
           *p++ 等价于 *(p++),表示先取得第 n 个元素的值,再将 p 指向下一个元素。

           *++p 等价于 *(++p),会先进行 ++p 运算,使得 p 的值增加,指向下一个元素,整体上相当于 *(p+1),所以会获得第 n+1 个数组元素的值。
           (*p)++ 就非常简单了,会先取得第 n 个元素的值,再对该元素的值加 1。假设 p 指向第 0 个元素,并且第 0个元素的值为 99,执行完该语句后,第 0 个元素的值就会变为 100。

    二、C 语言字符串指针(指向字符串的指针)

    ① 字符串数组:

    char str[] = "http://c.biancheng.net";
    int len = strlen(str), i;
    //直接输出字符串
    printf("%s\n", str);
    //每次输出一个字符
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }

    ② 字符串指针:

    C 语言还支持另外一种表示字符串的方法,就是直接使用一个指针指向字符串:

    char *str = "http://c.biancheng.net";
    
    char *str;
    str = "http://c.biancheng.net";
    
    上面两个相同

    字符串中的所有字符在内存中是连续排列的, str 指向的是字符串的第 0 个字符。

    char *str = "http://c.biancheng.net";
    int len = strlen(str), i;
    
    //直接输出字符串
    printf("%s\n", str);
    
    //使用*(str+i)
    for(i=0; i<len; i++){
    printf("%c", *(str+i));
    
    //使用str[i]
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }
    
    以上三种均可

    :都可以使用*或[ ]获取单个字符,这两种表示字符串的方式是不是就没有区别了呢?
    :有!它们最根本的区别是在内存中的存储区域不一样字符数组存储在全局数据区栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。

    三、C 语言指针数组(数组每个元素都是指针)

    一个数组中的所有元素保存的都是指针,那么我们就称它为指针数组
    此处一定要类比普通的指针使用方法

    int a = 16, b = 932, c = 100;
    
    //定义一个指针数组
    int *arr[3] = {&a, &b, &c};//也可以不指定长度,直接写作 int *parr[]
    
    //定义一个指向指针数组的指针
    int **parr = arr;
    
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));
    
    运行结果:
    16, 932, 100
    16, 932, 100

           arr 是一个指针数组,它包含了 3 个元素,每个元素都是一个指针,在定义 arr 的同时,我们使用变量 a、 b、 c 的地址对它进行了初始化,这和普通数组是多么地类似。
           parr 是指向数组 arr 的指针,确切地说是指向 arr 第 0 个元素的指针,它的定义形式应该理解为 int *(*parr),括号中的*表示 parr 是一个指针,括号外面的 int *表示 parr 指向的数据的类型。 arr 第 0 个元素的类型为 int *,所以在定义 parr 时要加两个 *。
           第一个 printf() 语句中, arr[i] 表示获取第 i 个元素的值,该元素是一个指针,还需要在前面增加一个 * 才能取得它指向的数据,也即 *arr[i] 的形式。
           第二个 printf() 语句中, parr+i 表示第 i 个元素的地址, *(parr+i) 表示获取第 i 个元素的值(该元素是一个指针),**(parr+i) 表示获取第 i 个元素指向的数据。

    #include <stdio.h>
    int main(){
    char *str[3] = {
    "https://blog.csdn.net/qq_38351824/article/category/9343538",
    "百度搜索",
    "sumjess"
    };
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
    }
    
    等价于
    
    #include <stdio.h>
    int main(){
    char *str0 = "https://blog.csdn.net/qq_38351824/article/category/9343538";
    char *str1 = "百度搜索";
    char *str2 = "sumjess";
    char *str[3] = {str0, str1, str2};
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
    }
    
    

    需要注意的是,字符数组 str 中存放的是字符串的首地址不是字符串本身,字符串本身位于其他的内存区域, 和字符数组是分开的。
    也只有当指针数组中每个元素的类型都是 char *时,才能像上面那样给指针数组赋值,其他类型不行。

    四、二维数组指针(指向二维数组的指针)

    二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例:

    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };


    C 语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a,它可以分解成三个一维数组,即 a[0]、 a[1]、a[2]。每一个一维数组又包含了 4 个元素,例如 a[0] 包含 a[0][0]、 a[0][1]、 a[0][2]、 a[0][3]。

    假设数组 a 中第 0 个元素的地址为 1000,那么每个一维数组的首地址如下图所示:

           为了更好的理解指针和二维数组的关系,我们先来定义一个指向 a 的指针变量 p:int (*p)[4] = a;括号中的*表明 p 是一个指针,它指向一个数组,数组的类型为 int [4],这正是 a 所包含的每个一维数组的类型。[ ]的优先级高于*, ( )是必须要加的,如果赤裸裸地写作 int *p[4],那么应该理解为 int *(p[4]), p 就成了一个指针数组,而不是二维数组指针。
           对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关, p 指向的数据类型是 int [4],那么 p+1 就前进 4×4 = 16 个字节, p-1 就后退 16 个字节,这正好是数组 a 所包含的每个一维数组的长度。也就是说, p+1 会使得指针指向二维数组的下一行, p-1 会使得指针指向数组的上一行。
           数组名 a 在表达式中也会被转换为和 p 等价的指针!
           下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义:

    1. p 指向数组 a 的开头,也即第 0 行; p+1 前进一行,指向第 1 行
    2. *(p+1)表示取地址上的数据,也就是整个第 1 行数据。注意是一行数据,是多个数据,不是第 1 行中的第 0 个。
    3. *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢?
      *(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个
      元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;
      就像一维数组的名字,在定义时或者和 sizeof、 & 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。
    4. *(*(p+1)+1)表示第 1 行第 1 个元素的。很明显,增加一个 * 表示取地址上的数据。
      a+i == p+i
      a[i] == p[i] == *(a+i) == *(p+i)
      a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)
      
      【实例】使用指针遍历二维数组
      
      #include <stdio.h>
      int main(){
      int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
      int(*p)[4];
      int i,j;
      p=a;
      for(i=0; i<3; i++){
      for(j=0; j<4; j++) printf("%2d ",*(*(p+i)+j));
      printf("\n");
      }
      return 0;
      }
      
      运行结果:
      0 1 2 3
      4 5 6 7
      8 9 10 11

      下面是一个简单的例子

    五、指针数组和二维数组指针的区别:

    指针数组和二维数组指针在定义时非常相似,只是括号的位置不同:

    int *(p1[5]);    指针数组,可以去掉括号直接写作 int *p1[5];
    int (*p2)[5];    二维数组指针,不能去掉括号

           指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1为例,在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。

    六、常见指针变量的例子集合:

    常见指针变量的定义
    定 义含 义
    int *p;p 可以指向 int 类型的数据,也可以指向类似 int arr[n] 的数组。
    int **p;p 为二级指针,指向 int * 类型的数据。
    int *p[n];p 为指针数组。 [ ] 的优先级高于 *,所以应该理解为 int *(p[n]);
    int (*p)[n];p 为二维数组指针。
    int *p();p 是一个函数,它的返回值类型为 int *。
    int (*p)();p 是一个函数指针,指向原型为 int func() 的函数。

    ① 二级指针:指向一级指针的地址

    #include <stdio.h>
    int main(){
    
    int a[2] = {0,1};
    
    int *pt1 = &a[1];   // 将 a[1] 的地址赋值给pt1 
    
    int **pt = &pt1;    // 二级指针 将指针pt1的地址赋值给pt 
    
    printf("利用二级指针pt 获取pt1的指针地址 :%p\n",pt );
    printf("显示自己(指针pt1)的地址 :         %p\n",&pt1 );
    
    return 0;
    }

    ② 指针数组:[ ]优先级高于 *,所以应该理解为  int * ( p[n] );

    #include <stdio.h>
    int main(){
    
    int a[4] = {0,1,2,3};
    
    int *pt[4] = { a, &a[1], &a[2], &a[3]};
    
    printf("显示  %p\n",&pt );     //打印数组的首地址, 
    printf("显示  %p\n",&pt[0] );  //也是数组第一个元素的地址 
    
    printf("显示  %p \n",pt[2]);   //打印第三个元素的地址
    printf("显示  %p \n", &a[2]);  //验证第三个元素的地址 是否正确 
    
    printf("显示  %d \n", a[2]);    //打印数组第三个数据 
    printf("显示  %d \n",*pt[2]);   //验证pt[2]到底是不是表示第三个元素的地址
    printf("显示  %d \n", *&a[2]);  //再次验证第三个元素的地址 是否正确 
    
    return 0;
    }

    ③ 二维数组指针

    #include <stdio.h>
    int main()
    {
    int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
    
    int i = 1 ,j = 2;
    
    int(*p)[4];  //二维数组指针p 
    
    p=a;  //二维数组指针p 指向 数组a的首地址
    
    printf("第i行,第j个元素的地址是 : %p \n",   (*(p+i)+j) );  //第i行,第j个元素的地址 
    printf("第i行,第j个元素的数值是 : %d \n", * (*(p+i)+j) );  //第i行,第j个元素的数值
    
    printf("验证:\n");
    
    printf("第i行,第j个元素的地址是 : %p \n",   &a[1][2] );  //第i行,第j个元素的地址 
    printf("第i行,第j个元素的数值是 : %d \n",    a[1][2] );  //第i行,第j个元素的数值
    
    return 0;
    }

    ④ int *p();  函数返回值类型为  int *

    #include <stdio.h>
    
    int n = 100;
    
    int *test(void) //返回一个int *类型(地址) 
    {
     return &n;
    }
    
    int main()
    {
     int *p , n;
     
     p = test();  //指针p指向这个地址 
     n = *p;      //从这个地址获取值 
     
     printf("value = %d\n", n); //该地址的值是否为 100 
     
     return 0;
    }

    ⑤ 函数指针:int (*p)() ; 

    #include <stdio.h>
    
    int m = 99;
    
    int *test(int * a) //第一个*代表返回一个int *类型(返回一个地址) 
    {                  //第二个*传入一个地址
     return a;         //return 返回一个地址 
    }
    
    int main()
    {
     int *p ;         //定义一个指针变量 
     int *(*pt)(int *c) = test ;  //第一个*函数指针:int (*p)() ;第一个* 是要与 test 函数参数列表一致。  
                                  //第二个*函数指针:int (*p)() ;
                                  //第三个*函数指针:int (*p)() ;第二个括号中的int *c 是要与 test 函数参数列表一致。 
                                  //下面再对比解释下。                              
                                  //int *(*pt)(int *c)     对比看一下实际就是将*pt = test ;其他部分一致 
                                  //int * test(int * a)    而*pt = test 就是pt指向函数首地址 	
    							  					  
     p = (*pt)(&m);   //函数(*pt)(&m)返回一个地址,指针p指向这个地址 
    //---------------------------------------------------------------------------------------------------//
    //上面的内容其实就做了一个简单的事情,将指针p指向全局变量m的地址(即p=&m),转这么一圈使用来学习指针的//
    // 下面就来验证,我们之前做的是对。                          
    	
     printf("m的地址为          :%p\n",&m);//这是m的地址 
     printf("验证指针:m的地址为:%p\n",p); //这是经过风波的m的地址,用来验证我们之前的一通指针操作是否正确
      
     printf("m的value =          %d\n",m); //该地址的值是否为 99
     printf("验证指针:m的value= %d\n",*p); //这是经过风波的m的值,用来验证我们之前的一通指针操作是否正确 
     
     return 0;
    }

     

    展开全文
  • 1、指针一个变量,占用内存空间,用来保存地址

    指针变量指针所指向的内存空间是两个不同的概念


    char*p = "123456";//p是一个指针变量存放在临时栈区,"123456"是一个字符串常量存放在常量区,变量p保存的是字符串的地址

    char*str = (char*)malloc(100);//将分配的100字节的堆区的内存空间的地址赋值给指针变量p

    strcpy(str,"123456");//将字符串拷贝到堆区


    1)指针也是一种变量,占有内存空间,用来保存内存地址

    2)*p操作内存
       在指针声明时,*号表示所声明的变量为指针
       在指针使用时,*号表示 操作 指针所指向的内存空间中的值
       *p相当于通过地址(p变量的值)找到一块内存;然后操作内存
       *p放在等号的左边赋值(给内存赋值)
       *p放在等号的右边取值(从内存获取值)
    3)指针变量和它指向的内存块是两个不同的概念
       含义1 给p赋值p=0x1111; 只会改变指针变量值,不会改变所指的内容;p = p +1; //p++
       含义2 给*p赋值*p='a'; 不会改变指针变量的值,只会改变所指的内存块的值 
       含义3 =左边*p 表示 给内存赋值, =右边*p 表示取值 含义不同切结!
       含义4 =左边char *p
       含义5 保证所指的内存块能修改
    4)指针是一种数据类型,是指它指向的内存空间的数据类型
        含义1:指针步长(p++),根据所致内存空间的数据类型来确定
        p++=(unsigned char )p+sizeof(a);
        结论:指针的步长,根据所指内存空间类型来定。

    5)一级指针易错模型:

    不断修改指针变量的值,然后又回过头来释放该内存的时候,程序就会出bug

    void main()

    {

        char*p = (char*)malloc(100);

        strcpy(p,"123456789");

        p = p + 2;//指针指向已经改变

        *p = 'a' ;

        //注意:C语言规定:要释放内存必须从内存首地址开始释放

        free(p)//现在又想释放原来所指向的空间,程序就会报错

    }

    解决该错误的方法是加一个辅助指针变量pstr用来定位到首地址

    void main ()
    {
     char*pstr = NULL;
     char*p = NULL;
     p=pstr= (char*)malloc(100);
     strcpy(p, "123456789");
     p = p + 2;//指针指向已经改变
     *p= 'a';
     p = p - 2;
     printf("%s", p);
     free(pstr);//现在又想释放原来所指向的空间,程序就会报错
     p = pstr = NULL;//避免产生野指针
     system("pause");
    }


    6)一级指针内存模型建立

    字符串一级指针内存模型图:

    注意:


    C语言字符串在堆区、栈区,常量区都可以存放字符串。

    1、char buf[20] = "aaaa" 将常量区aaaa拷贝到栈区 

    2、buf2[] = "bbbb"也是分配栈区空间和buf是一样的

    3、指针p1指向的是常量区的字符串,保存该字符串的地址

    4、指针p2指向的是堆区的内存空间,字符串从常量区拷贝到堆区




      

    
    展开全文
  • C指向结构体变量的指针(结构指针变量)

    千次阅读 多人点赞 2018-04-22 17:03:32
    个指针变量当用来指向一个结构体变量时,称之为结构体指针变量。结构体指针变量中的值是所指向的结构变量的首地址。通过结构指针变量即可访问该结构的变量。结构指针变量说明的一般形式如下:struct 结构名 *结构...

        一个指针变量当用来指向一个结构体变量时,称之为结构体指针变量。结构体指针变量中的值是所指向的结构变量的首地址。通过结构指针变量即可访问该结构的变量。


    结构指针变量说明的一般形式如下:

    struct 结构名 *结构指针变量名


        结构名和结构变量时两个不同的概念,不能混淆。结构名只能表示一个结构形式,编译系统并不会对它分配内存空间。只有当某变量被说明为这种类型的结构时,才对该变量分配存储空间。


        有了结构指针变量,就能更方便地访问结构变量的各个成员。其访问的一般形式为:    

        (*结构指针变量).成员名

        结构体指针变量->成员名    



    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
    	struct Student
    	{
    		char cName[20];
    		int iNumber;
    		char cSex;
    		int iGrade;
    	}student={"Girl",2017,'w',2};
    	
    	struct Student *pStruct; 
    	pStruct = &student;
    	printf("Name:%s\n",(*pStruct).cName);
    	printf("Number:%d\n",pStruct->iNumber);
    	printf("Sex:%c\n",student.cSex);
    }

    通过上面的代码可见,以下三种用于结构成员的形式是完全等效的。

    结构变量.成员名

    (*结构指针变量).成员名

    结构指针变量->成员名


    展开全文
  • 指针变量声明为const型,这样指针变量始终保持为初值,不能改变,即其指向不能改变 例 #include #include int main() { char cBuff1[100] = "1234"; char cBuff2[100] = "5678"; char * const
  • 指向函数的指针变量

    千次阅读 2018-08-14 11:16:23
    1. 说明: 函数在编译时会被分配给一个入口地址, 而指针变量用于存放地址(指针), 所以可以使用指针来指向函数并调用该函数, 这指针就是函数指针 . ...2) 若需要用指针调用函数, 必须先使用指针变量指向该函数...
  • 个指针变量之间可以相互赋值,p和q是int类型的指针。 p=q表示将q所指向的int类型变量的地址赋给p 2.两个都是指针,所以是p的值等于q 如果p不是指针,那么p=q是p等于q指向的值 3.可以这样写,前提好像是q有确定的...
  • C语言输出指针变量地址以及指向变量的地址

    万次阅读 多人点赞 2016-12-01 22:08:14
    #include #include <stdlib.h>int main() { int a = 100; int *ap = &a; printf("%p\n",&a);//输出:002AF744 输出的是a变量的地址 ...//输出:002AF744 通过指针变量ap输出a变量的地址 printf
  • #include<stdio.h> #include<stdlib.h> int main(int* argc, char *argv[]) ...printf("请输入三整型变量:\n"); scanf_s("%d%d%d", p1, p2, p3); if (*p1 > *p2) { temp = *p1; *p1 =
  • 个指针变量可不可以相减?

    千次阅读 2019-08-26 20:15:59
    遇到一道题,问:两个指针变量可不可以相减? 答案是:可以 以前只写过 “指针±整数”,比如数组方面的,两指针的运算还是第次碰。 《C和指针》里说: 只有当两指针都指向一个数组中的元素时,才允许从...
  • 指向结构体的指针&结构体成员指针

    万次阅读 2018-08-17 18:44:11
    指向一个结构体的指针变量,其值是结构体变量的起始地址。 /* *copyright(c) 2018,HH *All rights reserved. *作 者:HH *完成日期:2018年8月17日 *版本号:v1.0 * *问题描述:指向结构体变量的指针的应用 *输入...
  • “两个指针变量可以进行的运算”

    千次阅读 2019-08-06 09:28:50
    在牛客网上刷到了一道选择题: ...指针变量保存的是地址,而地址本质上是一个整数,所以指针变量可以进行部分运算,例如加法、减法、比较等。 #include<stdio.h> int main(){ int a=0; double b=9...
  • 指针函数与指向函数的指针变量

    千次阅读 2016-03-07 14:03:34
    可以一个指针变量指向函数,然后通过该指针变量调用此函数。 1. 指向函数的指针变量的一般定义形式为:  函数类型 (*变量名)(函数形参表)  2. #include  3. using namespace std;  4. int main...
  • 1 指向对象的常指针变量指向常对象的指针变量区别  Time * const p; //指向对象的常指针变量 p的值(p的指向)不能修改  const Time *p; //指向常对象的指针变量,p指向的类对象的值不能通过p来修改 1.1 ...
  • 定义了一个指向字符串的指针变量,并将字符串的首地址赋值给strp指针变量,即:使指针变量strp指向字符串首地址; 输出: (1)printf(“%s\n”,strp); (2)for(;*strp;strp++) printf("%c",*strp) ...
  • 1.指针变量的值。指的是P本身的值,写作P,在这里是a的地址,类型为int型; 2.指针地址的值,指的是p的地址值,写作&amp;p,这地址代表的内存,存储出是P的值,类型为**型,也就是二级指针; 3.指针指向的值,...
  • 结构数组的每一个元素是具有相同的结构类型的下标结构变量。在实际应用中,经常用结构数组来表示具有相同数据结构的一个群体。 如:一个班的学生的档案,一个车间职工的工资等。struct stu { Int num; char *...
  • 指向常对象的指针变量可以指向一个已经申明为常对象的变量,此时只能用指向常对象的指针变量指向它;也可以指向一个非常对象的变量,而此时可通过指针访问该对象,但是不能通过指针改变该对象的值。下面给出一简单...
  • int *p, *q; p=q; 这样写是什么意思?是p指向q吗?
  • 值得注意的是,理论上,指针变量寻址两次,二维指针变量寻址三次…n维指针变量寻址n+1次,且n可以无限增加,但是实际上,不同的寻址方式比如两次寻址和三次寻址,是在设计之初就被编进指令集中的,指令码的限制...
  • 这里主要是指的是字符串指针 比如 ``` 比如 char s1[]="hello";... char *t="www",我想让s内容变成"hellowww" 可以...这个可以实现么 不要函数不要循环复制 为什么不能让s+5=t,就是让它接下来指向t的地址呢
  • C++中交换两个变量的值的方法

    千次阅读 多人点赞 2019-11-05 18:21:03
    即不能通过将变量名传入函数的方式进行交换,因为这种方式是将值进行拷贝后作为参数传入函数,也就是说函数内部使用的拷贝的值,在函数执行完后就会销毁,而不是对变量的原值进行操作。 而在C++中需要通...
  • 指针和指针变量

    千次阅读 多人点赞 2019-05-12 22:06:11
    为了表示指针变量和他所指的变量之间的联系,在程序中用“*”表示"指向",如果定义变量 i 为指针变量,那么 *i 就表示指针变量 i 里面存放的地址所指向的存储单元里面的数据,很绕吧,可以在纸上画画。 ...
  • 指针总是指向变量的第一个字节的地址,即变量的首地址 转载于:https://www.cnblogs.com/clemente/p/10843781.html
  • 刚接触到指针时,关于指向变量的常指针指向变量指针容易混淆,所以整理下,希望能够帮助自己也帮助到大家。 常(量)指针指针就是我们说的指向常量的指针,顾名思义,它是用来指向常量的。 用常指针指向...
  • 我们在头文件中声明一个如下的类,定义一个指向该类自己的静态成员指针变量kpHttpClientInstance; class CHttpClient { public: CHttpClient(); ~CHttpClient(); static CHttpClient* GetInstance(); int ...
  • 指向一维数组a的指针变量实现对二维数组b中各元素的输入和输出 编写程序,用指向一维数组的指针变量p实现对二维数组b中各元素的输入和输出。要求:输出用指针变量的多种表现形式进行数组元素的多次输出。 完蛋 ...
  • 笔者在学习的过程中也受到了以上的困扰,经过查阅资料后,得到以下... 目的:一个指针变量所占字节数 */ #include<stdio.h> int main() { char ch = 'A'; int i = 9; double x = 7.3; char * p =&ch; ...
  • 如果将两个指针变量指向块动态内存,而其中一个生命期结束释放了该动态内存,这时候就会出现问题,另一个指针所指向的地址虽然被释放了但该指针并不等于NULL,这就是所谓的悬垂指针错误,这种错误很难被察觉,...
  • 首先,我们先介绍一下二维数组和二维数组的指针,二维数组相当于一个特殊的维数组里面每元素又是一个一维数组,例如:int a [ 3 ] [3],可以看成一个3行的一个列数组,每列的元素又是一个长度为3的数组,数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 599,798
精华内容 239,919
关键字:

任何一个指针变量都可以指向不同