精华内容
下载资源
问答
  • 这个函数的作用是,主函数的变量间接赋值,这是二级指针的一个应用。 主函数不必考虑getMem3这个子函数是怎样实现的,这个思想很重要。 // 这个函数作用是,计算文件1和文件2的长度 // main()中的变量,不需要知道...

    这个函数的作用是,给主函数的变量间接赋值,这是二级指针的一个应用。
    主函数不必考虑getMem3这个子函数是怎样实现的,这个思想很重要。

    // 这个函数作用是,计算文件1和文件2的长度
    // main()中的变量,不需要知道getMem函数是怎样实现的
    void getMem3(char **myp1,int *mylen1,char **myp2,int *mylen2)
    {
    	int ret = 0;
    	char *tmp1, *tmp2;
    	
    	tmp1 = (char*)malloc(100);
    	strcpy(tmp1, "11111111111");
    	// 间接赋值
    	*mylen1 = strlen(tmp1);  //1级指针
    	*myp1 = tmp1; //2级指针的间接赋值
    
    	tmp2 = (char *)malloc(200);
    	strcpy(tmp2, "22222222222");
    	*mylen2 = strlen(tmp2);// tmp2内存的大小
    	*myp2 = tmp2; //2级指针的间接赋值
    
    	return ret;
    }
    
    int main()
    {
    	int ret = 0;  // 在常量区开辟4个字节的内存空间,赋值为0
    	char *p1 = NULL; //在栈中开辟一个p1
    	int len1 = 0;	// 
    	char *p2 = NULL;//在栈中开辟一个p2
    	int len2 = 0;
    	getMem3(&p1, &len1, &p2, &len2);
    	
    	printf("p1:%s \n", p1);
    	printf("p2:%s \n", p2);
    
    
    	system("pause");
    	return 1;
    }
    

    下面是对应的内存图
    在这里插入图片描述

    展开全文
  • 二级指针

    2017-02-24 18:57:54
    //**p=*q=a二级指针作为函数参数的作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效,那么我们就需要二级指针。 二级指针在函数中的应用: 1,交换字符串变量void swap_str(char **a , ...
    int **p;
    int *q;
    int a;
    q=&a;
    p=&q;//p为指向指针q的指针;
    //*p=q,为指向a的指针
    //**p=*q=a

    二级指针作为函数参数的作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效,那么我们就需要二级指针。
    二级指针在函数中的应用:
    1,交换字符串变量

    /*
        a、b为指向str_a、str_b的指针
        交换字符串即交换str_a、str_b的指向
        更改指针的指向即更改指针内存中的值
        传入函数时需要获取地址进行更改,不然不会改变实参的值,与变量是一个道理
    */
    void swap_str(char **a , char **b)
    {
        char *temp = *a;
        *a = *b;
        *b = temp;
    }
    
    int main(void)
    {
        char *str_a = "hello world";
        char *str_b = "world hello";
        swap_str(&str_a , &str_b);
        printf("%s %s\n",str_a,str_b);
        system("pause");
        return 0;
    }

    2,O(1)时间删除链表节点

    /*
        O(1)时间删除链表节点,将待删除节点的Next复制给该节点,并删除Next节点
        当链表中只有一个节点时,需要改变头指针的指向,指向NULL
        所以需要传入指向头指针的指针
    */
    void DeleteNode(ListNode** pListHead,ListNode* pToBeDeleted)
    {
        if(!pListHead||!pToBeDeleted)
        {
            return;
        }
        //待删除节点为中间节点(有Next节点)
        if(pToBeDeleted->m_pNext != NULL)
        {
            ListNode* pNext =pToBeDeleted->m_pNext;
            pToBeDeleted->m_nValue=pNext->m_nValue;
            pToBeDeleted->m_pNext=pNext->m_pNext;
            delete pNext;
            pNext=NULL;
        }
        //链表只有一个节点,删除头节点
        if(*pListHead==pToBeDeleted)
        {
            delete pToBeDeleted;
            pToBeDeleted=NULL;
            *pListHead=NULL;
        }
        //删除尾节点
        else
        {
            ListNode *pNode=*pListHead;
            while(pNode->m_pNest!=pToBeDeleted)
            {
                pNode=pNode->m_pNext;
            }
            pNode->m_pNext=NULL;
            delete pToBeDeleted;
            pToBeDeleted=NULL;
        }
    }

    3,二叉搜索树转换为有序的双向链表

    /*
      递归
      中序遍历的顺序,左子树转换后的最后一个节点与根节点相连,
      根节点与右子树转换后的第一个节点相连
    */
    BinaryTreeNode* Convert(BinaryTreeNode* pRootNode)
    {
        BinaryTreeNode* pLastNodeInList=NULL;
        ConvertNode(pRootNode,&pLastNodeInList);//传入二级指针
        BinaryTreeNod* pHeadofList=pLastNodeInlist;
        while(pHeadofList->mLeft!=NULL & pHeadofList!=NULL)
        {
            pHeadofList=pHeadofList->mLeft;
        }
        return pHeadofList;
    }
    
    //需递归调用函数,改变pLastNodeInList的指向,所以传入二级指针
    void ConvertNode(BinaryTreeNode* pNode,BinaryTreeNode** pLastNodeInList)
    {
        if(pNode==NULL)
            return;
        BinaryTreeNode* pCurrent=pNode;
        if(pCurrent->mLeft!=NULL)
        {
            ConvertNode(pNode->mLeft,pLastNodeInList);
        }
        pCurrent->m_Left=*pLastNodeInList;
        if(*pLastNodeInList != NULL)   //不要忘记判断节点存在
        {
            pLastNodeInList->mRight=pCurrent;
        }
        *pLastNodeInList=pCurrent;
        if(pCurrent->mRight!=NULL)
        {
            ConvertNode(pNode->mRight,*pLastNodeInList);
        }
    }

    4,改错

    void GetMemory( char *p )//此处应传入二级指针
    {  
        p = (char *) malloc( 100 );
    } 
    void Test( void )  
    {  
        char *str = NULL;  
        GetMemory( str );   
        strcpy( str, "hello world" );  
        printf( str ); 
    }
    /*
    Test函数使用str作为形参传入,会产生指针的拷贝str_cpy即p传入GetMemory中,此时所分配的内存的地址是给拷贝的指针p。
    */
    展开全文
  • 首先确定优先级:()>[]>*,另外数组指针,类比整型指针,表示指向数组的指针指针数组,类比整型数组,表示元素为指针的数组。...一维数组赋值给数组指针时,需要取数组地址或对其进行强制转换,另外相当于...

    首先确定优先级:()>[]>*,另外数组指针,类比整型指针,表示指向数组的指针;指针数组,类比整型数组,表示元素为指针的数组。

    数组指针

    int (*p)[n] 首先()优先级高,它是一个指针,指向一个整型数组。n为数组的长度,当p+1时需要跨越n个整型数据的长度,通常用来表示二维数组及二维数组的函数传参。

    一维数组赋值给数组指针时,需要取数组地址或对其进行强制转换,另外相当于二维数组中只有一个行元素,p3+1的地址没有意义,*(p3+1)也无法显示。

    1 char a[5] = { 'A', 'B', 'C', 'D' };
    2 char(*p3)[5] = &a;
    3 char(*p4)[5] = (char (*)[5])a;

     二维数组赋值给数组指针时,具体间接访问格式,可以参考上一篇博文指针和数组的关系

    复制代码

     1 # include <stdio.h>
     2 int main(void)
     3 {
     4     int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
     5     int i, j;
     6     int (*p)[4] = a;  //记住这种定义格式
     7     for (i=0; i<3; ++i)
     8     {
     9         for (j=0; j<4; ++j)
    10         {
    11             printf("%-2d\x20", *(*(p+i)+j));  /*%-2d中, '-'表示左对齐, 如果不写'-'则默认表示右对齐;2表示这个元素输出时占两个空格的空间*/
    12         }
    13         printf("\n");
    14     }
    15     return 0;
    16 }

    复制代码

    二维数组元素地址赋值给一维指针,对元素进行访问时需要跨越n个整型数据的长度,即p + i*N +j == &a[i][j]

    复制代码

     1 # include <stdio.h>
     2 int main(void)
     3 {
     4     int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
     5     int i, j;
     6     int *p = &a[0][0];  //把a[0][0]的地址赋给指针变量p
     7     for (i=0; i<3; ++i)
     8     {
     9         for (j=0; j<4; ++j)
    10         {
    11             printf("%-2d\x20", *(p+i*4+j));
    12         }
    13         printf("\n");
    14     }
    15     return 0;
    16 }

    复制代码

     

    指针数组

     int *p[n] 首先[]优先级高,它是一个数组,前面为int*,表示数组的元素为整型指针,也可表示为int **p, 这里执行p+1时,则p指向下一个数组元素,这样赋值是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量,可以用来存放变量地址。

    其中C中处理字符串和链表数据结构中用该数据类型较多,涉及到二级指针时也容易出问题。

    复制代码

     1 int a = 1;
     2 int b = 2;
     3 int *p[2];
     4 p[0] = &a;
     5 p[1] = &b;
     6 
     7 printf("%p\n", p[0]); //a的地址
     8 printf("%p\n", &a); //a的地址
     9 printf("%p\n", p[1]); //b的地址
    10 printf("%p\n", &b); //b的地址
    11 printf("%d\n", *p[0]); //p[0]表示a的地址,则*p[0]表示a的值
    12 printf("%d\n", *p[1]); //p[1]表示b的地址,则*p[1]表示b的值
    13 
    14 
    15 //将二维数组赋给指针数组
    16 int *pp[3]; //一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2],所以要分别赋值
    17 int c[3][4];
    18 for (int i = 0; i < 3; i++)
    19     pp[i] = c[i];

    复制代码

    数组指针是一个指针变量,占有内存中一个指针的存储空间;

    指针数组是多个指针变量,以数组的形式存储在内存中,占有多个指针的存储空间。

    指向二维数组时,指针数组和数组指针访问数组元素时完全相同,但函数传参时,只能用数组指针,原因参见指针和数组的关系

    复制代码

    int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; //2行3列的二维整型数组
    int(*p)[3]; //数组指针,指向含有3个元素的一维数组
    int *q[2]; //指针数组,一个数组内存放2个指针变量
    
    p = a;
    q[0] = a[0];
    q[1] = a[1];
    
    //输出第1行第2列的值
    printf("%d\n", a[1][2]); //5
    
    printf("%d\n", *(p[1] + 2)); //5
    printf("%d\n", *(*(p + 1) + 2)); //5
    printf("%d\n", (*(p + 1))[2]); //5
    printf("%d\n", p[1][2]); //5
    
    printf("%d\n", *(q[1] + 2)); //5
    printf("%d\n", *(*(q + 1) + 2)); //5
    printf("%d\n", (*(q + 1))[2]); //5
    printf("%d\n", q[1][2]); //5

    复制代码

    一级指针和二级指针

     在进行函数指针传参时,编译器总是要为函数的每个参数制作临时副本(即形参为实参的副本),在调用的时候,实参和形参是不同的内存空间,只是,这个内存空间存放的指针指向的是同一块地址 ,所以形参在函数执行中可以访问实参指向的内存空间,但是形参的指向的改变(即形参所指向的内存空间与实参不同)并不能影响实参,但改变形参所指向的空间的值时(改变形参指向的内存空间的值),实参指向会改变。

    一级指针的作用:在函数外部定义一个值m,在函数内对m进行赋值改变,函数结束后对值m生效。一级指针不管形参、实参都指向值m的地址,对一级指针进行解引用时都是访问m的地址空间,然后访问m,因此若改变形参指向的空间的值(即改变了m的值),则实参也会改变。

    二级指针作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效。二级指针不管形参、实参都指向指针p,对二级指针进行解引用时都是先访问指针p的地址空间,再访问指针p,因此若改变形参指向的空间的值(即改变了指针p的值),则实参也会改变。

    如果用了二级指针,但不想改变外部的指针p,可以在函数内部对二级指针指向的空间的值做一个拷贝。

    复制代码

     1 void  my_malloc(char **s)  
     2 {  
     3     *s=(char*)malloc(100);  
     4 }  
     5  
     6 void  main()  
     7 {  
     8     char  *p=NULL;  
     9     my_malloc(&p);
    10     //do something
    11     if(p)
    12         free(p);  
    13 }  

    复制代码

    这里给指针p分配内存,do something,然后free(p),如果用一级指针,那么就相当于给一个p的拷贝s分配内存,p依然没分配内存,用二级指针之后,才对p分配了内存。

    应用上面的二级指针的例子

    复制代码

     1 void getstring_(char **p){
     2     //char *p;
     3     *p = malloc(100);
     4     memset(*p, 0, 100);
     5     strcpy(*p, "hello");
     6 }
     7 
     8 void test_(){
     9     char *ret = NULL;
    10     getstring_(&ret);
    11     printf("%s\n", ret);
    12 }
    13 
    14 int main(){
    15     test_();
    16 
    17     system("pause");
    18     return 0;
    19 }

    复制代码

    展开全文
  • 二级指针的作用详解 首先确定优先级:()>[]>*,另外数组指针,类比整型指针,表示指向数组的指针;指针数组,类比整型数组,表示元素为指针的数组。 数组指针 int (*p)[n] 首先()优先级高,它是一个指针...

    数组指针和指针数组

    二级指针的作用详解

    首先确定优先级:()>[]>*,另外数组指针,类比整型指针,表示指向数组的指针;指针数组,类比整型数组,表示元素为指针的数组。

    数组指针

    int (*p)[n] 首先()优先级高,它是一个指针,指向一个整型数组。n为数组的长度,当p+1时需要跨越n个整型数据的长度,通常用来表示二维数组及二维数组的函数传参。

    一维数组赋值给数组指针时,需要取数组地址或对其进行强制转换,另外相当于二维数组中只有一个行元素,p3+1的地址没有意义,*(p3+1)也无法显示。

    1 char a[5] = { 'A', 'B', 'C', 'D' };
    2 char(*p3)[5] = &a;
    3 char(*p4)[5] = (char (*)[5])a;

     二维数组赋值给数组指针时,具体间接访问格式,可以参考上一篇博文指针和数组的关系

     1 # include <stdio.h>
     2 int main(void)
     3 {
     4     int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
     5     int i, j;
     6     int (*p)[4] = a;  //记住这种定义格式
     7     for (i=0; i<3; ++i)
     8     {
     9         for (j=0; j<4; ++j)
    10         {
    11             printf("%-2d\x20", *(*(p+i)+j));  /*%-2d中, '-'表示左对齐, 如果不写'-'则默认表示右对齐;2表示这个元素输出时占两个空格的空间*/
    12         }
    13         printf("\n");
    14     }
    15     return 0;
    16 }

    二维数组元素地址赋值给一维指针,对元素进行访问时需要跨越n个整型数据的长度,即p + i*N +j == &a[i][j]

     1 # include <stdio.h>
     2 int main(void)
     3 {
     4     int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
     5     int i, j;
     6     int *p = &a[0][0];  //把a[0][0]的地址赋给指针变量p
     7     for (i=0; i<3; ++i)
     8     {
     9         for (j=0; j<4; ++j)
    10         {
    11             printf("%-2d\x20", *(p+i*4+j));
    12         }
    13         printf("\n");
    14     }
    15     return 0;
    16 }

     

    指针数组

     int *p[n] 首先[]优先级高,它是一个数组,前面为int*,表示数组的元素为整型指针,也可表示为int **p, 这里执行p+1时,则p指向下一个数组元素,这样赋值是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量,可以用来存放变量地址。

    其中C中处理字符串和链表数据结构中用该数据类型较多,涉及到二级指针时也容易出问题。

     1 int a = 1;
     2 int b = 2;
     3 int *p[2];
     4 p[0] = &a;
     5 p[1] = &b;
     6 
     7 printf("%p\n", p[0]); //a的地址
     8 printf("%p\n", &a); //a的地址
     9 printf("%p\n", p[1]); //b的地址
    10 printf("%p\n", &b); //b的地址
    11 printf("%d\n", *p[0]); //p[0]表示a的地址,则*p[0]表示a的值
    12 printf("%d\n", *p[1]); //p[1]表示b的地址,则*p[1]表示b的值
    13 
    14 
    15 //将二维数组赋给指针数组
    16 int *pp[3]; //一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2],所以要分别赋值
    17 int c[3][4];
    18 for (int i = 0; i < 3; i++)
    19     pp[i] = c[i];

    数组指针是一个指针变量,占有内存中一个指针的存储空间;

    指针数组是多个指针变量,以数组的形式存储在内存中,占有多个指针的存储空间。

    指向二维数组时,指针数组和数组指针访问数组元素时完全相同,但函数传参时,只能用数组指针,原因参见指针和数组的关系

    int a[2][3] = { { 0, 1, 2 }, { 3, 4, 5 } }; //2行3列的二维整型数组
    int(*p)[3]; //数组指针,指向含有3个元素的一维数组
    int *q[2]; //指针数组,一个数组内存放2个指针变量
    
    p = a;
    q[0] = a[0];
    q[1] = a[1];
    
    //输出第1行第2列的值
    printf("%d\n", a[1][2]); //5
    
    printf("%d\n", *(p[1] + 2)); //5
    printf("%d\n", *(*(p + 1) + 2)); //5
    printf("%d\n", (*(p + 1))[2]); //5
    printf("%d\n", p[1][2]); //5
    
    printf("%d\n", *(q[1] + 2)); //5
    printf("%d\n", *(*(q + 1) + 2)); //5
    printf("%d\n", (*(q + 1))[2]); //5
    printf("%d\n", q[1][2]); //5

    一级指针和二级指针

     在进行函数指针传参时,编译器总是要为函数的每个参数制作临时副本(即形参为实参的副本),在调用的时候,实参和形参是不同的内存空间,只是,这个内存空间存放的指针指向的是同一块地址 ,所以形参在函数执行中可以访问实参指向的内存空间,但是形参的指向的改变(即形参所指向的内存空间与实参不同)并不能影响实参,但改变形参所指向的空间的值时(改变形参指向的内存空间的值),实参指向会改变。

    一级指针的作用:在函数外部定义一个值m,在函数内对m进行赋值改变,函数结束后对值m生效。一级指针不管形参、实参都指向值m的地址,对一级指针进行解引用时都是访问m的地址空间,然后访问m,因此若改变形参指向的空间的值(即改变了m的值),则实参也会改变。

    二级指针作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效。二级指针不管形参、实参都指向指针p,对二级指针进行解引用时都是先访问指针p的地址空间,再访问指针p,因此若改变形参指向的空间的值(即改变了指针p的值),则实参也会改变。

    如果用了二级指针,但不想改变外部的指针p,可以在函数内部对二级指针指向的空间的值做一个拷贝。

     1 void  my_malloc(char **s)  
     2 {  
     3     *s=(char*)malloc(100);  
     4 }  
     5  
     6 void  main()  
     7 {  
     8     char  *p=NULL;  
     9     my_malloc(&p);
    10     //do something
    11     if(p)
    12         free(p);  
    13 }  

    这里给指针p分配内存,do something,然后free(p),如果用一级指针,那么就相当于给一个p的拷贝s分配内存,p依然没分配内存,用二级指针之后,才对p分配了内存。

    应用上面的二级指针的例子

     1 void getstring_(char **p){
     2     //char *p;
     3     *p = malloc(100);
     4     memset(*p, 0, 100);
     5     strcpy(*p, "hello");
     6 }
     7 
     8 void test_(){
     9     char *ret = NULL;
    10     getstring_(&ret);
    11     printf("%s\n", ret);
    12 }
    13 
    14 int main(){
    15     test_();
    16 
    17     system("pause");
    18     return 0;
    19 }

     

    转载于:https://www.cnblogs.com/qinguoyi/p/10116416.html

    展开全文
  • 只有6行代码,非常简洁,这是char二级指针给char二维数组赋值的逻辑。二级指针需要赋值操作,加断点就可以看见二维数组里的值了。
  • C语言 二级指针

    2016-11-27 17:12:47
    通过二级指针去访问二维数组需要给二级指针分配等同于二维数组行数的一维数组指针,然后把二维数组的每行首地址赋值给对应位置的一维指针上。之后就可以通过二维指针直接访问了。 参考代码如下,可以看具体注释...
  • 通过二级指针去访问二维数组需要给二级指针分配等同于二维数组行数的一维数组指针,然后把二维数组的每行首地址赋值给对应位置的一维指针上。之后就可以通过二维指针直接访问了。 参考代码如下,可以看具体注释...
  • 所以,在处理字符串的时候,经常会遇到二级指针。下面来总结一下自己学到的东西: 1. 字符数组和字符指针 把字符数组赋值给一个字符指针,直接赋值就可以,不需要在字符数组前加取地址符&。 2. 字符数组...
  • 通过二级指针去访问二维数组需要给二级指针分配等同于二维数组行数的一维数组指针,然后把二维数组的每行首地址赋值给对应位置的一维指针上。之后就可以通过二维指针直接访问了。 参考代码如下,可以看具体注释...
  • c/c++---之用二级指针操作二维数组

    千次阅读 2018-11-28 15:59:34
    通过二级指针去访问二维数组需要给二级指针分配等同于二维数组行数的一维数组指针,然后把二维数组的每行首地址赋值给对应位置的一维指针上。之后就可以通过二维指针直接访问了。 参考代码如下,可以看具体注释...
  • 首先二级指针作为函数参数的作用:在函数外部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效,那么我们就需要二级指针。不懂没有关系,继续往下看~加油! 在如上的A指向B、B指向C的指向关系中,如果A、B...
  • 结构体中包含二级指针案例

    万次阅读 2018-10-24 20:32:41
    出如下结构体,要求全部在堆区开辟空间。有多个老师,每个老师有多个学生。 typedef struct { char *name;//老师 int stu_num;...需要注意以下问题: ... 外层循环处理这三个成员...stu_num赋值stu_arr开辟5个...
  • 前文:C++之指针探究(六):二级指针和数组指针 void指针:通用指针,可以指向任意类型的数据。也就是说,任何类型的指针都可以赋值给void指针。     将任何类型的指针转换为void指针都是没问题的,但如果要转换...
  • 指针的定义

    2020-03-27 09:11:34
    指针&&指针变量 指针是地址 ...所以什么时候是指针变量的地址,什么时候是指针变量存放的地址,尤其在有二级指针或数组时 没分配空间就给指针赋值 char *p; //定义一个指针存放字符串 s...
  • 应该先从整体上学习指针的知识体系,再接着去学习一级指针、二级指针、多级指针,甚至于指针数组、数组指针,最后才能有基础去学习更加复杂难懂的函数指针、指针函数。 一、 指针细节归纳 指针是一种变量,会...
  • C语言总结(三)

    2017-05-10 18:44:08
    C语言总结(三)二级指针二级指针也是指针变量,指针都是存储地址的变量,而二级指针是存储所指向的一级指针变量...作用:在函数外部顶一个指针p,在函数内给指针赋值,函数结束后对指针p神效,那么我们就需要二级指针
  • 5.2.1 变量赋值 5.2.2 读取变量的值 5.2.3 位置变量和其他系统变量 5.2.4 引号的作用 5.3 数值运算命令 5.4 条件表达式 5.4.1 if表达式 5.4.2 Case表达式 5.5 循环语句 5.5.1 for语句 5.5.2 while语句 5.5.3 until...
  • 实现步骤: 二叉树的实现: ... 是否有根,即是否根为空,空则赋值,这也是为啥要传入2级指针的目的,记得只要修改根就需要传入二级指针 d. 不空即有根的情况,设置一个变量,为当前节点 i
  • 5.2.1 变量赋值 36 5.2.2 读取变量的值 37 5.2.3 位置变量和其他系统变量 37 5.2.4 引号的作用 37 5.3 数值运算命令 38 5.4 条件表达式 40 5.4.1 if 表达式 40 5.4.2 case 表达式 41 5.5 循环语句 42 5.5.1 for ...
  • 给指针变量pb赋值,pb指向变量b。 本行的意义是求a+b之和,(*pa就是a,*pb就是b)。 本行是求a*b之积。 输出结果。 输出结果。 ...... 指针变量还可以与0比较。设p为指针变量,则p==0表明p是空指针,它不指向任何...
  • 零起点学通C++多媒体范例教学代码

    热门讨论 2010-11-30 09:35:13
    6.3.6 不要赋值 6.3.7 对象只能调用类中存在的方法 6.4 公有 6.5 私有 6.6 成员函数的声明和定义 6.7 内联函数 6.7.1 普通内联函数 6.7.2 内联成员函数 6.8 头文件与源文件 6.9 const成员函数 6.10构造函数 6.11...
  • 6.3.6 不要赋值 6.3.7 对象只能调用类中存在的方法 6.4 公有 6.5 私有 6.6 成员函数的声明和定义 6.7 内联函数 6.7.1 普通内联函数 6.7.2 内联成员函数 6.8 头文件与源文件 6.9 const成员函数 6.10...
  • 谭浩强教授曾获全国高校教学成果国家奖、国家科技进步奖,以及北京市政府授予的“有突出贡献专家”称号。《计算机世界》报组织的“世纪评选”把他评为我国“20世纪最有影响的IT人物”10个人之一(排在第2位)。他...
  • 可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此往复,以至无穷。 数组大小 1.23 能否声明和传入数组大小一致的局部数组,或者由其他参数指定...
  • 可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此往复,以至无穷。 12  数组大小 13 1.23 能否声明和传入数组大小一致的局部数组,或者由...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    书中列出了C用户经常问的400多个经典问题,涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预处理器等各个方面的主题,并分别出了解答,而且结合代码示例阐明要点。 《你必须知道的495个C语言问题》结构...
  • 21天学通C++ (中文第五版)

    热门讨论 2010-06-23 16:57:03
    15.3.3 将函数指针传递其他函数 15.3.4 将typedef用于函数指针 15.4 成员函数指针 15.5 小结 15.6 问与答 15.7 作业 15.7.1 测验 15.7.2 练习 第16章 高级继承 16.1 聚合 16.1.1 访问被聚合类的...

空空如也

空空如也

1 2 3 4
收藏数 79
精华内容 31
关键字:

给指针赋值需要二级指针