精华内容
下载资源
问答
  • 失败案例: int fuzhi(float* data) { int num = 10; float* new_data = new float[num]; for (int i = 0; i < num; i++) { new_data[i] = i; } data = new_data;... vector&

    失败例子:

    int fuzhi(float* data) {
    
    	int num = 10;
    	float* new_data = new float[num];
    	for (int i = 0; i < num; i++) {
    	
    		new_data[i] = i;
    			
    	
    	}
    	data = new_data;
    	return 0;
    }
    int main(int argc, char **argv)
    {
    
    	Solution* so = new Solution();
    	vector<int> nums;
    
    
    	float* data=new float[10];
    	fuzhi(data);
    	int num = 10;
    
    	for (int i = 0; i < num; i++) {
    
    		cout << data[i] << endl;
    
    
    	}
    }

     

    成功例子:

    int fuzhi(float* data) {
    
    	int num = 10;
    	float* new_data = new float[num];
    	for (int i = 0; i < num; i++) {
    	
    		data[i] = i;
    			
    	
    	}
    	//data = new_data;
    	return 0;
    }
    int main(int argc, char **argv)
    {
    
    	Solution* so = new Solution();
    	vector<int> nums;
    
    
    	float* data=new float[10];
    	fuzhi(data);
    	int num = 10;
    
    	for (int i = 0; i < num; i++) {
    
    		cout << data[i] << endl;
    
    
    	}

     

    展开全文
  • 数组指针(也称行指针) 定义: int (*p)[n]; ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。 如要将二维...

    数组指针(也称行指针)

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

            如要将二维数组赋给一指针,应这样赋值:

    int a[3][4];
    int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。
    p=a;         //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]
    p++;         //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]

            所以数组指针也称指向一维数组的指针,亦称行指针。

    指针数组

            定义: int *p[n];
            []优先级高,先与p结合成为一个数组,再由int*说明这是一个整型指针数组,它有n个指针类型的数组元素。这里执行p+1时,则p指向下一个数组元素,这样赋值是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值,a的首地址的值。
            如要将二维数组赋给一指针数组:

    int *p[3];
    int a[3][4];
    p++;        //该语句表示p数组指向下一个数组元素。注:此数组每一个元素都是一个指针
    for(i=0;i<3;i++)
    p[i]=a[i]   //这里int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2],所以要分别赋值。

            这样两者的区别就豁然开朗了,数组指针只是一个指针变量,是C/C++语言里专门用来指向二维数组的,它占有内存中一个指针的存储空间。指针数组是多个指针变量,以数组形式存在内存当中,占有多个指针的存储空间。
            还需要说明的一点就是,同时用来指向二维数组时,其引用和用数组名引用都是一样的。
    比如要表示数组中i行j列一个元素:
            *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

            优先级:()>[]>*

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

    2021-05-04 09:21:47
    数组在传入时,实际上只传入指向其首元素的指针数组在“退化”时会丢失边界。 void average(int ary[12]); //形参ary是一个int * //... int anArray[] = {1,2,3}; average(anArray); //合法 void average(int ...

    一、数组形参

    数组在传入时,实际上只传入指向其首元素的指针。数组在“退化”时会丢失边界。

    void average(int ary[12]); //形参ary是一个int *
    //...
    int anArray[] = {1,2,3};
    average(anArray); //合法
    
    void average(int ary[], int size); //传统的做法是将数组大小传入

    如果数组边界的精确数组很重要,并且希望函数只接受含特定数量的元素的数组,可以考虑引用形参

    void average(int (&ary)[12]); //只接受大小为12的int数组
    average(anArray); //错误!anArray是int[3]

    多维数组形参,只是第一维数组退化为指针,后面的维数边界没有退化,否则无法对形参执行指针算术

    void process(int ary[10][20]);
    void process(int (*ary)[20]); //ary是一个指针,指向一个大小为20的int数组
    void process(int ary[][20]); //建议定义为这样,更清晰

    二、指针算术

    指针+1不是将指针的地址增加一个字节,而是按照所指对象的大小比例进行,增加sizeOf()个字节。这也是void *不支持指针算术的原因,因为不知道指向对象的类型。

    //一维数组
    int ary[5] = {1,2,3,4,5};
    int *ptr=(int*)(&ary+1); //&ary+1的单位是int(*)[5]
    printf("%d\n%d\n",*(ary+1),*(ptr-1)); //结果 2 5
    printf("sizeof(ary)=%d\n",sizeof(ary)); //结果 20
    printf("sizeof(&ary)%d\n",sizeof(&ary)); //结果 4(32位系统)
    /**
    ary是数组首地址ary[0]的地址,&ary是对象(数组)首地址;
    ary+1是数组下一个元素的地址,即ary[1];而&ary+1是下一个对象的地址,即ary[5]。
    sizeof(ary) 是 数组的空间大小,即 5 * 4 = 20;
    sizeof(&ary),&ary是一个指向int型数据的指针
    **/
    
    //多维数组
    int a[3][4];
    int (*p)[4] = a; //p指向int[4]数组,所指对象大小是sizeof(int)*4,而不是一个int。
    
    //a+i,a[i],*(a+i),&a[i][0]是等同的,都是第i个一维数组的首地址。
    //&a[i]和a[i]也是等同的,二维数组不存在元素a[i]
    
    //*(p+i)是一维数组a[i][0]的地址; *(p+2)+3表示a[2][3]地址,*(*(p+2)+3)表示a[2][3]的值。
    

    同类型的指针可以做减法运算,结果为两个指针之间的元素个数(而不是它们之间的字节数)

    三、数组指针和指针数组

    数组指针:是一个指针,指向一个数组

    指针数组:是一个数组,数组元素是指针

    int *p1[10]; //指针数组。[]的优先级比*高,p1[]构成一个数组,int*是数组元素。p1是数组的名字,指向数组第一个元素。
    int (*p2)[10]; //数组指针。()优先级比[]高,*p2定义一个指针,int是数组元素。p2指向一个匿名的int[10]数组。

    两者访问二维数组:

    //数组指针
    int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int (*p)[4];
    p = (int(*)[4])a;
    for(int i=0; i<3; i++)
    {
        for(int j=0;j<4;j++) printf("%d",p[i][j]); //或者 *(*(p+i)+j) 或者 *(p[i]+j)
        printf("\n");
    }
    
    
    //指针数组
    int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    int *p[3];
    for(int ix = 0; ix<3; ix++) p[ix] = a[ix];
    for(int i=0; i<3; i++)
    {
        for(int j=0;j<4;j++) printf("%d",p[i][j]); //或者 *(*(p+i)+j) 或者 *(p[i]+j)
        printf("\n");
    }

    四、常量指针和指针常量

    常量指针:指针是常量

    指针常量:指向常量的指针

    T *pt = new T; //一个指向T的指针
    const T *pct = pt; //一个指向const T的指针。等同于 T const* pct.
    T *const cpt = pt; //一个const指针,指向T
    
    const T *const cpct1 = pt; //一个指向常量的常量指针。等同T const *const cpct1

    一个指向非常量的指针可以转换为一个指向常量的指针。但相反的转换是非法的。

    const T acT;
    pct = &acT;
    pt = pct; //错误!
    *pt = aT; //视图修改常量对象!
    
    pt = const_cast<T *>(pct); //没有错,但这种做法不妥
    *pt = aT; //视图修改常量对象!

    五、函数指针

    int *f1(); //一个返回值为int *的函数
    void (*fp)(int); //fp是一个指向返回值为void, 参数为int的函数的指针
    
    extern void h(int);
    fp = h; //OK
    fp = &h; //OK, &可有可无,通常省略
    
    (*fp)(12); //显示解引用
    fp(12); //隐式解引用,结果相同

     

    展开全文
  • 一:指针数组 写法:int* p[10];//*p未用括号括起来,说明[]的优先级高,p先和[]结合成数组,在被前面的*定义为一个指针类型的数组。 顾名思义:就是一个指针类型的数组,既然是指针类型的数组,所以数组中...

    一:指针数组

    写法:int* p[10];//*p未用括号括起来,说明[]的优先级高,p先和[]结合成数组,在被前面的*定义为一个指针类型的数组。

      顾名思义:就是一个指针类型的数组,既然是指针类型的数组,所以数组中存放的元素就是一个个指针,这就决定了我们不能随便为其赋值。废话少说,上代码。

    tip1.透过代码看本质。 

    int* p[10] = {1};//这样为其初始化就会报错,因为数组里面的元素全是指针类型,不能用整型为其初始化。
    int* p[10] = { NULL };//这样做就不会报错,还是因为里面都是指针类型的元素。

    tip2:不能为其随便赋值,因为指不定那个指针指向哪,你怎么能随便就往人家原来的内存块里写东西。

    int* p[10] = { NULL };
    *p[0] = 1;//报错,

    tip3:内存示意图

    tip4:灵活运用的小案例

    //如要将二维数组赋给一指针数组:
    	int* p[3];
    	int a[3][4];
    
    	for (int i = 0; i < 3; i++)
    		p[i] = a[i]
    //这里int * p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]
    //所以要分别赋值。

     

    二:数组指针

    顾名思义:就是数组的一个指针,先定义一个数组,再让一个指针指向他。

    数组指针(也称指向一维数组的指针,也称行指针) 定义语法: int (*p)[n]; //n是一行里有几个元素,也就是列数
    //()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n行的长度。

    tip1.将二维数组赋给一个指针 

    如要将二维数组赋给一指针
    int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
    int (*p)[4]; //该语句是定义一个数组指针
     p=a;        //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0],下面会有一个小片段简介名字和首地址的关系。
     p++;       //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]
    
    

    tip2:验证p指向的内容

    for (int i = 0; i < 3; i++) {
    		cout << p[i] << " ";
    		p++;
    	}

    看下图,可以看出连续的三个行指针。且每两个之间恰好相差16个字节,正好把我那每行四个整型数据存进去。 

     

    for (int i = 0; i < 3; i++) {
    			cout <<* p[0] << " ";//解引用,看看他到底输出那个元素。我们想让他输出每行第一个元素
    			p++;
    	}

     

    根据结果,确实是每行的第一个元素,说明p++直接就是一次跨行  ,//该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]。

     

    三:名字和首地址的关系:

    void test01(){
    	//验证名称首地址的测试块,下面那三种写法表示相同的地址(均为首元素的地址)
    	  int arr[3][3]={{1,2,3},{4,5,6},{7,8,9}};
          cout<<"&arr[0][0]: "<<&arr[0][0]<<endl;
          cout<<"arr:        "<<arr<<endl;
          cout<<"arr[0]:     "<<arr[0]<<endl;
    }

     

    再深入的讲:

    既然都是首地址,那到底有没有区别哪?

    答案是有的。

    现在再来看看下面的代码:

    int main()
    {
       char a[5]={'A','B','C','D'};
       char (*p3)[5] = &a;//正确
       char (*p4)[5] = a;//错误
       return 0;
    }

     

     p3 和p4 都是数组指针,指向的是整个数组。&a 是整个数组的首地址,a是数组首元素的首地址,其值相同但意义不同

    下面那个不正确的原因也就很显而易见了,就=就是我们不能把一个元素的首地址给了赋给数组类型。

     

    展开全文
  • 数组指针:是一个指针,指向一个数组 指针函数:是一个函数,函数返回值为一个指针 函数指针:是一个指针,指向一个函数 下面我们再看看具体定义与内容: 1、指针数组 int arr_value[3]; int *arr_p; int *...
  • 数组的类型数组指针怎么写声明返回一个数组指针的函数函数的类型函数指针怎么写 数组的类型 在往常的编程中,我们都知道数组的名字就代表数组第一个元素的地址,这总是让我们对数组的类型产生误解。比如对于这条指令...
  • 数组指针与地址 学习C++写了下面一段代码, 然后对其中一个小小问题(这问题很low,看到的兄弟别笑话我哈哈)思考了一下: 下面这个函数,为什么原型是int arr[ ] ,调用时候用的却是数组的名称呢? 原来我一直混淆...
  • C/C++ 数组指针及引用的区别1.数组指针的区别(1)定义数组是一个符号,不是变量,因而没有自己对应的存储空间。但是,指针是一个变量,里面存储的内容是另外一个变量的地址,因为是变量所以指针有自己的内存空间...
  • C/C++数组指针

    2021-11-22 22:57:08
    C/C++数组指针
  • C++ 中,将 char * 或 char[] 传递给 cout 进行输出,结果会是整个字符串,如果想要获得字符串的地址(第一个字符的内存地址),可使用以下方法:强制转化为其他指针(非 char*)。可以是 void *,int *,float *, ...
  • 数组指针:有一个指针,指向了数组的首地址 int *p[10]; //指针数组 int (*p)[10]; //数组指针 二. 指针函数与函数指针 指针函数:函数的返回值类型是指针 函数指针:有一个指针,其指向了一个函数 int* add(int a,...
  • 数组指针:指的是数组名的指针,即数组首元素地址的指针。 函数返回数组指针,然后我们可以获取整个数组的值。 代码 int a[40]; // DoSomething // a 数组的值已经变了,这时候我们要返回 a数组的值给别的类使用...
  • c++通过指针输出对象的数组数据

    千次阅读 2021-01-02 15:13:14
    //定义对象的数组 cout“请输入五组数据,中间要有空格:”(i=0; i; i++) { cin>>x>>y; S[i].Get_date(x, y);//利用定义的数组进行Get_data函数值的接收 } cout“成功输出的数据是:”(i=0; i; i++) { S[i].show(); } ...
  • 深入理解数组指针与指针数组,基于Dev C++测试 数组指针与指针数组数组指针(行指针)指针数组测试 数组指针与指针数组 指出:[ ]的优先级比*高,两种区别在于先形成数组还是先形成指针,先形成数组为指针数组。 数组...
  • 数组和数组名问题一、指针1.1 指针变量和普通变量的区别1.2 为什么需要指针1.3 指针使用三部曲二、整形、浮点型数组前言2.1 数组名其实是特殊的指针2.2 理解复杂的数组的声明2.3 数组名a、数组名取地址&a、数组...
  • C++ 二维数组指针遍历

    2021-08-03 17:07:29
    二维数组在内存中存储是线性连续的,可以计算出二维数组的偏移量,进而使用一级指针遍历二维数组 #include<stdio.h> void printMatirx(int *pArray,int rows,int cols) int main() { int array[2][3] ={{1,...
  • C++ 将字符串传递到函数后,使用 sizeof 产生的问题
  • 二、数组指针 int (*p_a)[5]表示数组指针 此时p_a中的地址为该数组第一个元素的地址。 根据《二重指针、二维数组及二者如何进行赋值_jiongta9473的博客-CSDN博客》这篇文章中3.2的特别说明,可以知道: int (*p_a)...
  • 数组指针与指针数组、函数指针与指针函数、类模板与模板类、函数模板与模板函数的区别。
  • C++普通数组转vector

    千次阅读 2020-12-21 17:13:55
    因此,比较好的做法就是直接取第一个元素的地址,得到了首地址,之后的做法与数组也是大同小异了。 举例说明。 假设函数Func需要以数组的方式传递,函数原型如下: void Func(double* pDataAddress, size_t ...
  • 既然 delete 时无需提供数组大小,那么显然编译器是知道数组的大小(或者说界限的)。那么编译器是如何知道数组大小的?(比如维护了一张表、按特定格式存储……)既然知道数组大小,编译器能否自动检查数组越界的情况?...
  • 1.定义指针 语法
  • 指针数组与数组指针详解 1.什么是指针数组和数组指针? 指针数组:指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统...
  • 我们首先弄清楚指针数组与数组指针的概念。 指针数组:指针数组是一个数组,只不过数组里面元素全是指针 int* p[3]; int num[3]={1,2,3}; for (int i = 0; i < 3; i++) { p[i]=&num[i]; cout<&...
  • 指向具有M个元素的一维数组指针 定义格式如下: 类型 (*指针变量)[M]; //M为一整型常量 通常利用该指针变量,指向二维数组的行地址,其中M表示二维数组的列数。 例如:利用行指针变量,按行输出二维数组各元素值 ...
  • a数值上等于整个数组的起始位置地址,含义上代表整个数组所占内存的大小,&a + 1 等于的是数组结束之后的下一段的起始位置地址 &a[i]就是取第i个元素的存储地址 QVector b = {…}; xxx* c; a == b.data() ==...
  • } //输出 张三 100 李四 99 王五 80 初学c++遇到难点,在这做个笔记 数组本身就是地址,所以不需要加取址符&。 指针指向的是数组的第一个地址。 每个地址由两部分组成:名字和分数。各占4个字节。每个地址占8个字节...
  • c++数组指针导图

    2021-04-09 13:45:56
  • C++指针数组

    2021-08-02 10:34:09
    当我们声明一个数组后,数组的名字单独列出来往往被理解为指向数组首元素的指针,验证代码如下: #include <iostream> using namespace std; int main() { int ary[3]={1,2,3}; cout<<&ary[0]<...
  • *pa[n] //an array of pointers 注意这里[]优先级高于*,...换句话说,这里将原本的数组名pa 替换为 *pd,*pd就是指针数组,(*pd)[i]就是数组元素,即指针。 auto pc = pa; //a pointer to a pointer // pc[i] .

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,006
精华内容 119,602
关键字:

c++数组指针

c++ 订阅