精华内容
下载资源
问答
  • 本文较为详细的分析了关于理解C++指针数组,数组指针,数组名,二维数组的一些技巧。是比较重要的概念,相信对于大家的C++程序设计有一定的帮助作用。 一、关于数组名 假设有数组: int a[3] = {1, 2, 3} 1.数组...
  • C++指针数组释放问题

    2020-11-11 22:20:53
    答:b为指针数组,也是个数组,只不过元素为指针; delete[]b;是释放数组b的资源,这时候b仅仅是个数组,仅释放数组b本身的资源,没有释放数组b中元素(数组)的资源, delete[]b后a的资源根本没释放掉。 ...

    记录一个经典的问题,在群里有被问到这个问题,如下,

    请问这段代码中delete[]b 为什么可以正确运行呀?

    b1,b3同时指向了一个指针a,delete[] b的时候不会重复删除吗?

    答:b为指针数组,也是个数组,只不过元素为指针;
    delete[]b;是释放数组b的资源,这时候b仅仅是个数组,仅释放数组b本身的资源,没有释放数组b中元素(数组)的资源,

    delete[]b 后a的资源根本没释放掉。

    展开全文
  • c++指针数组,int *,char *,string *

    千次阅读 多人点赞 2019-07-03 18:59:36
    c++指针数组 指针数组≠数组指针,指针数组归根结底是个数组,数组的元素是指针。数组指针归根结底是个指针,指向数组的第一个元素。我们以int型、char型、str型指针数组为例。 整型指针数组 #include<iostream&...

    c++指针数组

    指针数组≠数组指针,指针数组归根结底是个数组,数组的元素是指针。数组指针归根结底是个指针,指向数组的第一个元素。我们以int型、char型、str型指针数组为例。

    整型指针数组

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main()
    {
        int a[5]={1,2,3,5};
        int *pa[5];//定义一个指向整型数据的指针数组
        for(int i=0;i<5;i++)
        {
            pa[i]=&a[i];//取数组元素的地址赋给指针
            cout<<pa[i]<<setw(7)<<*pa[i]<<endl;
            //pa[i]输出数组元素的地址,*pa[i]输出数组元素的值
            //setw()标准输出间隔控制函数
        }
        return 0;
    }
    

    需要注意的是,pa[i]输出数组元素的地址,*pa[i]输出数组元素的值。
    运行以上程序,结果是:

    0x7fff3fcf5350      1                                                                                                   
    0x7fff3fcf5354      2                                                                                                   
    0x7fff3fcf5358      3                                                                                                   
    0x7fff3fcf535c      5                                                                                                   
    0x7fff3fcf5360      0  
    

    数组元素不够时,c++会自动补0,如上述最后一行。

    字符型指针数组

    字符型和整型是很不一样的

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main()
    {
        char b[5]={'h','a','p','p','y'};
        char *pb[5];//定义一个指向字符型数据的指针数组
        for(int i=0;i<5;i++)
        {
            pb[i]=&b[i];//取数组元素的地址赋给指针
            cout<<setw(7)<<pb[i]<<setw(7)<<*pb[i]<<endl;
        }
        return 0;
    }
    

    运行以上程序的结果为

    happy      h                                                                                                          
       appy      a                                                                                                          
        ppy      p                                                                                                          
         py      p                                                                                                          
          y      y
    

    可见,pb[i]并没有输出b[i]的地址,而是把该指针所指字符及其后所有字符一并输出,直到遇到\0停止。*pb[i]输出的是具体字符。如果需要输出b[i]每个元素的存储地址,可以用下述指令:

    cout<<static_cast<void *>(pb[i])<<endl;
    
    0x7ffceadd9933
    0x7ffceadd9934
    0x7ffceadd9935
    0x7ffceadd9936
    0x7ffceadd9937
    

    每个字符的存储地址就会打印出来,并且可以发现,每个字符只需要一个字节的存储空间。

    字符串指针数组

    可以用指针数组来保存一系列的字符串

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main()
    {
        char *pc[5]={"happy","wife","happy","life","haha"};
        for(int i=0;i<5;i++)
        {
            cout<<pc[i]<<setw(7)<<*pc[i]<<setw(13)<<static_cast<void *>(pc[i])<<endl;
        }
        return 0;
    }
    

    运行以上程序,结果如下:

    happy      h     0x400b77                                                                                               
    wife      w     0x400b7d                                                                                                
    happy      h     0x400b77                                                                                               
    life      l     0x400b82                                                                                                
    haha      h     0x400b87
    

    可以看出 pc[i] 输出的是每一个字符串的值,因为一个字符只占一个字节,连续保存,自然连续读取。
    而 *pc[i] 输出的是每个字符串的首字符; static_cast<void *>(pc[i]) 可以输出每个字符串的首地址。如果要知道这个字符串数组中每个元素的长度(即包含几个字符)和所占内存的大小,可以用下述代码:

    #include<iostream>
    #include<iomanip>
    #include<string>
    using namespace std;
    int main()
    {
        char *pc[5]={"happy","wife","happy","life","haha"};
        string str[5];//声明一个字符串数组
        for(int i=0;i<5;i++)
        {
            str[i]=pc[i];//指针的长度不等于字符串长度,把指针所指的空间的内容赋给字符串数组
            /*cout<<pc[i]<<setw(7)<<*pc[i]<<setw(13)<<static_cast<void *>(pc[i])<<endl;*/
            cout<<str[i].length()<<setw(13)<<sizeof(str[i])<<endl;
            //使用<string>库里面的length()函数或size()函数都可以得到字符串长度
            //使用sizeof公式可以获取每个字符串所占的内存空间的大小,以我的电脑为例,都是8.
        }
        return 0;
    }
    

    运行以上代码,结果为:

    5            8                                                                                                          
    4            8                                                                                                          
    5            8                                                                                                          
    4            8                                                                                                          
    4            8
    

    这里要纠正一点,把指针赋值给字符串数组是会报出警告的,所以在输出每个字符串所占内存的大小时,全部输出8,这并不代表每个字符串所占内存空间为8,反而是因为把指针赋值给字符串数组,会把指针所占的内存空间的大小给输出,因为指针所占内存空间的大小等于电脑位数/8,以我的电脑为例,是8个字节。
    至于输出字符串所占内存的大小,期待后续补充。

    直接用string 定义一个字符串数组

    string str[5]={"happy","wife","happy","life","haha"};
    

    这样的程序很简单,但是使用指针的话更灵活,以上作为参考。

    展开全文
  • C++指针数组详解

    2020-04-15 14:42:34
    指针数组也是数组,它与普通数组区别是两者元素不一样 int数组每个元素都是int型,数组名a对应首元素a[0]的地址,因此数组名a是int*型 而指针数组,比如int *p[10],其每个元素都是int*型,数组名p对应首元素p[0]...

    数组名都表示第一个元素的地址,比如int a[3],则a表示&a[0]

    指针数组也是数组,它与普通数组区别是两者元素不一样

    int数组每个元素都是int型,数组名a对应首元素a[0]的地址,因此数组名a是int*型

    而指针数组,比如int *p[10],其每个元素都是int*型,数组名p对应首元素p[0]的地址,因此数组名p是int**型

    int *是指向int型数值地址的指针

    int**是指向指针变量地址的指针

    所以当指取值的时候,第一个只要一个*就能答得到地址对应的值。而第二个需要2个*。

    下面举一个例子:

    void main(int argc, char *argv[])
    {
        int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
        int *p[3];
        p[0] = a[0]; //a[0]与&a[0][0]等同,因此p[0]储存a[0][0]的地址
        p[1] = a[1]; //p[1]储存a[1][0]的地址
        p[2] = a[2]; //p[2]储存a[2][0]的地址
    
        cout<<p<<endl; //指针数组第一个元素p[0]的地址,0019FEF4
        cout<<*p<<endl; //指针数组第一个元素p[0]的内容,即&a[0][0],0019FF00
        cout<<&a[0][0]<<endl;  //0019FF00
        cout<<**p<<endl; //p[0]中储存的地址所指的内容,即a[0][0],1
        
        cout<<p+1<<endl; //指针数组第二个元素p[1]的地址,0019FEF8
        cout<<*(p+1)<<endl; //指针数组第二个元素p[1]的内容,即&a[1][0],0019FF10
        cout<<&a[1][0]<<endl; //0019FF10
        cout<<**(p+1)<<endl; //p[1]中储存的地址所指的内容,即a[1][0],5
    
        int **q;
        q = p; //指针数组p是int*类型,因此其数组名p是int**类型
        printf("%d\n", **q);
        q++; //相当于上面的p+1
        printf("%d\n", **q); //5
    }

     

    展开全文
  • C++指针数组的简单用法

    千次阅读 2020-08-02 00:18:31
    流程:先用指针获得数组的首地址,通过解指针获得相应数组元素变量,因为地址后移四个字节(整型数组),对应整型指针则表示为+1 若要循环遍历数组,加个for循环就行了和普通数组一样。 #include<iostream> ...

    利用指针访问数组
    流程:先用指针获得数组的首地址,通过解指针获得相应数组元素变量,因为地址后移四个字节(整型数组),对应整型指针则表示为+1
    若要循环遍历数组,加个for循环就行了和普通数组一样。

    #include<iostream>
    using namespace std;
    int main(){
    
    int a[10]={1,2,3,4,5,6,7,8,9,10};
    cout<<"第一个元素:"<<a[0]<<endl;
    int *p=a;//a就是数组首地址
    cout<<"利用指针访问第一个元素:"<<*p<<endl; 
    
    return 0;
    }
    

    在这里插入图片描述

    #include<iostream>
    using namespace std;
    int main(){
    
    int a[10]={1,2,3,4,5,6,7,8,9,10};
    cout<<"第一个元素:"<<a[0]<<endl;
    int *p=a;//a就是数组首地址
    cout<<"利用指针访问第一个元素:"<<*p<<endl; 
    p++;//让指针往后移四个字节,因为这里是整型指针,所以只要指针+1就可 
    cout<<"利用指针访问第二个元素:"<<*p<<endl; 
    return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 主要介绍了C++中用new创建二维数组和指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下
  • C++指针 数组 内存释放 相关说明
  • 封装一个函数,利用冒泡排序,实现对整形数组的升序排序 #include<iostream> using namespace std; void maopao(int *a,int len){ for(int i=0;i<len-1;i++){ for(int j=0;j<len-1-i;j++){ if(*...
  • 主要介绍了C++中的指针结构体数组以及指向结构体变量的指针的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 如下 int *a[0] int *a[1] 指针1 指针2 那么我们就分析出来这个 int * a[]也就是一个指针数组,只不过我们没有指定它的长度,需要我们在后面的大括号中初始化,写入几个指针就有几个指针的长度。 也就是说对于上面的...
  • C++ 指针 数组 字符串

    2018-12-18 22:42:13
    C++中,如果定义的是字符串数组的话,那么如果想获取数组的长度,只能用sizeof(数组名),而不能用strlen(str) sizeof(...)是运算符,在头文件中typedef为unsigned int,其值在编译时即计算好了,参数可以是数组...
  • 数组指针和指针数组,今天你肯定会看懂。
  • C++ 指针数组 & 指向数组的指针

    千次阅读 2017-12-19 14:25:27
    参考自《C++ Primer》template void disp(T i) { cout; }int main() { int i = 0; int j = 1; int arr[2][2] = {{1,2},{3,4}}; // 长度为2的指针数组 int *p[2]; p[0] = &i;
  • c++指针数组.rar

    2011-11-16 09:54:40
    c++指针数组.rarc++指针数组.rarc++指针数组.rarc++指针数组.rarc++指针数组.rarc++指针数组.rarc++指针数组.rarc++指针数组.rar
  • c++数组指针和指针数组详解

    千次阅读 多人点赞 2019-03-14 15:33:16
    指针数组指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中,指针占四个字节。 数组指针: 数组指针可以说成是”...
  • C++数组的指针、指针数组指针数组的指针的声明有点绕,防止后面绕晕记不住所以记录下。 指针数组 int *ap[3]; 为啥[3]要放在这里呢?[]优先级要高于*,所以[3]表明三个元素的数组,剩下的描述元素的类型,*表明...
  • 有两个指针数组,char *A[10] , char * B[10]; 首先: memcpy(A,B,10); 然后调用一个函数,其形参是一个指针数组,在这个函数里面是用strtok函数对字符串进行分割,比如传入的是A。为什么这个函数执行完了之后,B中...
  • C++指针 数组 内存释放

    千次阅读 2014-12-29 15:16:17
    和其它变量一样,指针是基本的变量,所不同的是指针包含一个实际的数据,该数据代表一个可以找到实际信息的内存地址。这是一个非常重要的概念。许多程序和思想依靠指针作为他们设计的基础。 开始  怎样定义一个...
  • 数组指针、指针数组与二级指针数组指针与指针数组数组指针指针数组二级指针二级指针的特性指向指针数组的数组指针与二级指针测试代码 数组指针与指针数组 数组指针是指针,意为指向数组的指针; 指针数组是数组,意...
  • 一:指针数组 写法:int* p[10];//*p未用括号括起来,说明[]的优先级高,p先和[]结合成数组,在被前面的*定义为一个指针类型的数组。 顾名思义:就是一个指针类型的数组,既然是指针类型的数组,所以数组中...
  • C++声明指针数组

    2020-10-07 15:31:25
    我们可以创建整型数组,也可以创建指针数组,即 int *api[10]; 二、解释 为了弄清这个复杂的声明,我们假定它是一个表达式,并对它进行求值。下标引用的优先级高于间接访问,所以在这个表达式中,首先执行下标...
  • NULL 博文链接:https://448230305.iteye.com/blog/2191121
  • 前言:想用字符指针数组char* strArr[10];存储多个字符串,通过while循环赋值产生的bug。 先看一段代码: main(){ char *strArr[5];//存储字符串的数组 char str[10]; int i = 0; char *p = NULL; while (i<...
  • c++ 指针及指针数组

    千次阅读 2017-09-16 01:19:38
    首先解释下指针数组及数组指针区别: 指针数组:array of pointers,即用于存储指针的数组,也就是数组元素都是指针 数组指针:a pointer to an array,即指向数组的指针 int s[6] = {1,2,3,4,5,6}; int *p1 = ...
  • c++动态申请指针数组

    2020-10-27 21:24:24
    c++中动态申请指针数组遇到的问题 当动态申请指针数组时需要用到二级指针,比如 int** a = new int*[n]; 这个时候,指针数组中的每一个单指针还没有申请空间,因此需要用一个循环来为单指针分配空间 for(int i = 0;...
  • C++中的数组指针和指针数组

    千次阅读 2018-12-01 12:49:22
    using namespace std; int main(){ //a) 一个整型数( An integer) int a; //b) 一个指向整型数的指针( A ... //c) 一个指向指针的的指针,它指向的指针是指向一个整型数( A pointer to a pointer to an ...
  • 先了解一下数组的结构,然后接着了解动态数组的结构。 数组数组: (1)数组大小固定。 (2)数组是一种复合类型 (3)存放类型相同的对象的容器,需要通过所在位置访问这些对象。 (4)数组的元素应该为对象,...
  • 指针访问数组元素 指针的运算本身就是适合对连续的数据进行处理,而数组正好满足这一要求。所以这一节研究如何使用指针访问数组元素。 首先我们举个例子 int a[10],*p;//定义一个数组和一个指针变量p p=a;//或者p=&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,346
精华内容 114,138
关键字:

c++指针数组

c++ 订阅