在取消引用指向数组的指针时，我得到的地址与指向数组的指针的地址相同
在取消引用指向数组的指针时，得到的地址与指向数组的指针的地址相同，这是因为指针本身存储的是数组的首地址。
指针是一个变量，它存储了另一个变量的内存地址。在C语言中，数组名本身就是一个指向数组首元素的指针。当我们取消引用指向数组的指针时，实际上是获取该指针所指向的内存地址上的值。
假设有一个数组arr，其首地址为ptr。当我们使用*ptr来取消引用指向数组的指针时，得到的是数组的首元素的值。而当我们使用ptr来获取指针的地址时，得到的是数组的首地址，即ptr的值。
这种情况下，取消引用指向数组的指针得到的地址与指向数组的指针的地址相同，因为它们指向的是同一个内存地址。
这种操作在访问数组元素时非常常见，可以通过指针来遍历数组，或者通过指针进行数组元素的读取和修改操作。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（ECS）：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：https://cloud.tencent.com/product/cdb
- 云原生容器服务（TKE）：https://cloud.tencent.com/product/tke
- 人工智能平台（AI Lab）：https://cloud.tencent.com/product/ailab
- 物联网开发平台（IoT Explorer）：https://cloud.tencent.com/product/iothub
- 移动推送服务（TPNS）：https://cloud.tencent.com/product/tpns
- 云存储（COS）：https://cloud.tencent.com/product/cos
- 区块链服务（TBC）：https://cloud.tencent.com/product/tbc
- 腾讯元宇宙（Tencent Metaverse）：https://cloud.tencent.com/solution/metaverse
相关·内容
1回答
如果我有下面的代码行，为什么b-a = 2？
int a[] = {1,2,3,4,5};
int *b = &(a[2]);
浏览 3提问于2020-11-17得票数 1
回答已采纳
3回答
如何引用指向数组的指针来获取存储在其中的值？例如：
void testFunction(int **test){
printf("%d", *test[1]);
}
int main()
{ int test[10];
test[1] = 5;
testFunction(&test);
return 0;
}
我得到一个错误。有谁能解释一下吗？
浏览 1提问于2013-06-05得票数 0
在C语言中，当我们使用指针访问a[i][j]时，为什么在*(*(a + i) + j)中需要第二个*？在使用printf()时，我看到a + i和*(a + i)打印出相同的值。
浏览 0提问于2010-08-22得票数 1
回答已采纳
3回答
理解和操作整数数组的指针
、、、
下面的代码有问题：
int a[] = {1, 2, 3, 4};
fprintf(stdout,
"a : %lu\n"
"*a : %d\n"
"&a : %ld\n"
"**(&a) : %d\n",
(unsigned long int)a,
*a,
(unsigned long int)&a,
**(&a)
);
输出：
a
浏览 4提问于2020-06-30得票数 1
5回答
了解指针和数组
、、
有没有人能解释一下数组是如何被它的名字引用的，通过在前面加上指针和双指针指向它的名字，就像下面的代码一样：
#include<stdio.h>
main()
{
int a[3][2];
a[0][0]=15;
a[0][1]=150;
a[1][0]=115;
a[1][1]=165;
a[2][0]=135;
a[2][1]=139;
printf( "%u\n", a);
printf( "%u\n", *a);
printf( "%u\n",
浏览 0提问于2012-12-02得票数 2
2回答
我的代码：
.h文件：
extern const int* g_position;
inline DWORD pos_x(BYTE v) {
if (1 <= v && v <= 3)
return g_position[v][0];
return 0;
}
inline DWORD pos_y(BYTE v) {
if (1 <= v && v <= 3)
return g_position[v][1];
return 0;
}
.cpp文件：
const int*
浏览 3提问于2014-08-06得票数 1
1回答
我正在用C语言编写链接列表，我遇到了这个问题:我不明白下面的陈述。在这里我的链接列表的结构
typedef struct node {
int value;
struct node *next;
} node;
下面是我正在研究的代码：
void reverse(reverse **list)`void reverse(reverse **list)
{
struct node * prev = NULL;
struct node * next;
struct node * current = list[0];
while(current!= NU
浏览 4提问于2016-04-02得票数 1
回答已采纳
4回答
我在过去的c#考试题中遇到了麻烦，我从这个链接中发现了这个问题，
问题是：
-C程序员正在使用一台字节为8位、单词为4字节的端机器。编译器支持非对齐访问，并分别使用1、2和4个字节来存储char、short和int。程序员编写以下definitions (右下角)以访问主内存中的值(左以下)：
地址字节偏移量
0x04 - 10 00 00
0x08 / 61 72 62 33
0x0c / 33 0000
0x10 \ 78 0c 00
0x14 / 08 00 00
0x18 / 01 00 4c 03
0x1c / 18 0000
int **i=(int **)0x04;
sh
浏览 8提问于2011-03-28得票数 13
回答已采纳
3回答
当我们需要将数组赋值给指针时，我们会这样做。
int numbers[] = {7,5,9,3};
int *ptr = NULL;
ptr = &numbers[0]; // <<
我们也可以通过这样做来做同样的事情。
int numbers[] = {7,5,9,3};
int *ptr = NULL;
ptr = numbers; // <<
两种方式的区别是什么?
和推荐的是哪一个?
浏览 4提问于2013-12-06得票数 0
回答已采纳
4回答
考虑到我们有一个类似于以下的课程，我对此感到困惑：
#ifndef SOMECLASS
#define SOMECLASS
class SomeClass
{
public:
SomeClass();
SomeClass(int);
~SomeClass();
void foo(const int&);
}
#endif
以及它的实施..。
因此，在主要职能方面：
int main(int argc, char **argv){
SomeClass* smc=new SomeClass();
cou
浏览 1提问于2015-09-06得票数 1
回答已采纳
#include <iostream>
using namespace std;
int main() {
int arr[5] = {5, 8, 1, 3, 6};
int len = *(&arr + 1) - arr;
cout << "The length of the array is: " << len;
return 0;
}
对于上面的代码，我不太理解这两段代码在做什么：
*(&arr + 1)
和
*(&arr)
&arr
有人能解释一下吗？因为当我运行以下两
浏览 0提问于2020-04-16得票数 8
2回答
有人能给我解释一下为什么这段代码有效吗？！！
我知道A持有&A，这不是一个真正的指针，好像你cout<<&A你会得到&A，但这个结果在我看来很奇怪。
int main()
{
double A[] = {2.4, 1.2, 4.6, 3.04, 5.7};
int len = *(&A+1) - A; // Why is this 5?
cout << "The array has " << len << " elements." << endl
浏览 0提问于2018-04-03得票数 2
回答已采纳
为什么所有三个print语句都给出相同的输出？
#include <stdio.h>
int main(void) {
int arr[]={1,2,3,4,5};
printf("%d\n",arr);
printf("%d\n",&arr);
printf("%d\n",*(&arr));
return 0;
}
浏览 23提问于2017-03-12得票数 3
回答已采纳
3回答
我认为整数数组的类型是指向整数的指针，因此这意味着指向整数数组的指针是指向整数的双指针类型。但我得到的结果却不是这样。我怀疑类型整数数组不是指向整数的类型指针。
以下是我的例子：
int main(){
int p[3]={1,2,3};
int (*ptr)[3] = &p;
int **ptr2 = &p;
printf("%d\n",(*ptr)[0]);
printf("%d\n",**ptr2);
return 0;
}
p为3类元素整数数组。
&p是指向3元素整数数组的指针类型。
ptr是指向3元素整
浏览 0提问于2019-06-12得票数 3
回答已采纳
2回答
C中的解引用局部数组
、、、、
根据我对C的理解，您可以将指针变量和数组变量视为等效变量，因为它们最终都是指针(一个指向本地函数堆栈，另一个指向内存中的任意随机点)。
通常，当需要返回指针时，我会将指针传递给指针(例如char ** pvar)，因此我可以看到将指针传递回取消引用的本地数组是多么没有意义，因为您不能更改变量的位置。
我的期望是，如果我尝试这样做，编译器将允许我这样做，然后分段错误或崩溃，当我试图设置返回的指针值。
但是，当试图取消数组类型(&数组)引用时，编译器会帮助生成关于使用不兼容类型的警告，然后将指针传递给数组，从接收函数的角度来看，实际上失去了一个间接的级别。
#include <std
浏览 0提问于2018-09-26得票数 0
回答已采纳
在编写程序时，我发现
(*array3)[i]
是不同于
*array3[i]
我不太明白为什么。有人能给我解释一下电脑里发生了什么吗？
第一个片段做我想做的事情，即:通过数组进行索引。在最后一个片段中，首先完成索引，然后是取消引用。我怎么能想象到呢？
int *array3 = nullptr;
void add(int *array1, int n1, int *array2, int n2, int **array3, int &n3){
n3 = std::max(n1,n2);
*array3 = new int[n3];
n3可能是任意数字
第一个案件的图
浏览 6提问于2020-11-16得票数 0
回答已采纳
3回答
我有一个指向10的整数数组的指针。取消对这个指针的引用应该给我带来什么？
例如：
#include<stdio.h>
main()
{
int var[10] = {1,2,3,4,5,6,7,8,9,10};
int (*ptr) [10] = &var;
printf("value = %u %u\n",*ptr,ptr); //both print 2359104. Shouldn't *ptr print 1?
}
浏览 0提问于2009-07-05得票数 13
回答已采纳
4回答
我被问到这个问题作为课堂练习：
int A[] = {1,3,5,7,9,0,2,4,6};
printf("%d\n", *(A+A[1]-*A));
我在纸上找不到它，所以继续编译一个简单的程序并对其进行测试，发现printf("%d",*A)总是为我提供1作为输出。
不过，我仍然不明白为甚麽会这样，所以如果有人可以解释一下便好了。
浏览 0提问于2016-06-01得票数 3
文档表示关于数组中单元格的指针的以下内容：
如果表达式P指向数组对象的第一个元素，则表达式(P)+N (等价地，N+(P))和(P)-N (其中N的值为n)分别指向数组对象的i+n和if元素，条件是它们的存在。
我有一个数组是这样声明的：
static int heap [MANY];
我输出指向堆的指针：
printf("heap = %ld\n", heap);
产出表明：
heap = 4227136
这就是指向heap[0]的指针，对吗？
接下来，我输出指向heap[1]的指针
printf("heap + 1 = %ld\n", (heap+1
浏览 7提问于2021-03-24得票数 0
回答已采纳
3回答
下面的代码显示指向数组的第一个元素的指针。ptr显示它所指向的地址，而*ptr则打印该地址的值，这是预期的。
int arr[]={1,2};
int *ptr=arr; //same as int *ptr=&arr[0]
cout<<"\n\n";
cout<<"Value at "<<ptr<<"is "<<*ptr<<endl;
输出：
Value at 003CFB48is 1
在下面的代码中，指针指向一个由2个元素组成的数组(而不是特别指向数组的一个元素)
浏览 0提问于2015-08-18得票数 1
我比较了各种printf，以更好地理解int *和int (*)[]之间的区别，以及如何可视化各种地址和值。
在下面的程序中，我写了一件困扰我的事情：
#include <stdio.h>
int main() {
int a[3] = {1,2,3};
int *p = a;
printf("address of a: %p\n", &a);
printf("\naddress of a[0]: %p\n", &a[0]
浏览 6提问于2022-08-17得票数 0
回答已采纳
*&在printf语句中的用法是什么?输出R是如何实现的？
#include <stdio.h>
int main() {
char* str = "ReplyCodeChallenge";
printf("%c\n", *&*str);
return 0;
}
输出为:r
浏览 1提问于2020-02-22得票数 2
回答已采纳
在这个程序中，我提到的三个地址都引用了数组的第一个元素，但是当我取消引用它们时，为什么不能获得数组的第一个元素的值呢？
int main()
{
int a[5] = {1,2,3,4,5};
printf("address a = %d\n",a);
printf("address of a[0] = %d\n",&a[0]);
printf("address of first element = %d\n",&a);
printf("value of fi
浏览 0提问于2012-08-20得票数 1
a[1][2]由如下编译器展开：*( *(a+1) +2 )。所以如果a有这样一个原型：int **a，
上述表述应解释如下：
从符号表中获取a的地址。注意，它是指向指针a 的指针，现在我们按1添加它，然后它指向a指向的位置。，然后取消引用它。我认为是一个未定义的行为，因为我们不知道a+1是否有效，我们随意地访问它。Ok，如果我们足够幸运，成功地得到了*(a+1)值。我们通过2.Upon添加这个步骤，我们取消引用(*(a+1) +2 )。我们现在走运了吗？
我在第10章的C专家编程中读到了这个，这是对的吗？
浏览 0提问于2011-04-13得票数 3
回答已采纳
1回答
这个Q 让我研究指针和数组:我确认它们非常相似，但不完全相同。
&a[0]是a或&a的详细表单。但是&对[]的优先级是多少呢？
当我将parens放在错误的方式(如(&a)[1] )时，这会改变值，但不会改变(&a)[0]。
#include <stdio.h>
int main(){
int a[3] = {10,20,30};
int *b;
b = a;
printf("%p a\n", a);
printf("%p a+1\
浏览 2提问于2021-05-04得票数 1
3回答
为了充分理解指针、值和引用是如何工作的，我正在编写一个基本的C++程序，试图篡改一些静态和动态数组，并准确地了解它们应该如何传入。
首先，我生成一个由3个元素组成的静态数组。然后，我将它传递到一个修改所有元素的函数中。然后，我将它传递给另一个具有稍微不同签名的函数，但也可以更改数组的值。
接下来，我生成一个动态大小的数组，通过引用将它传递到一个函数中，这样就可以修改这个动态大小数组中的所有值。
守则如下：
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace
浏览 7提问于2015-02-26得票数 1
回答已采纳
4回答
int a=10;
int *p=&a;
现在看看&*p，我们首先看看*p，它是10，然后是&10，它是10的地址或a的地址
在*&p的情况下，我们首先查看p的地址，然后查看此地址中的值10
但是我知道*&p和&*p是一样的，为什么？
浏览 1提问于2018-12-27得票数 0
假设我有一个名为arr的整数数组。我试图理解*&arr和*&arr[0]之间的区别。
我在C++中看到，arr本质上是指向数组中的第一个元素的指针，而&arr是指向整个数组的指针。他们都寄回了相同的地址，我知道这部分。然后，如果输入*&arr[0]，则返回第一个元素，即arr[0]处的值。但是如果输入*&arr，则返回arr[0]的地址。我的问题是，为什么当我使用*&arr时，返回的是地址，而不是第一个元素？逻辑将规定，由于运算符*返回值，人们期望*&arr返回第一个元素，而不是一个地址。
谢谢。
浏览 0提问于2020-03-29得票数 1
1回答
我想使用链式冲突处理来实现一个简单的哈希表。main.c:
int main ()
{
const int size = 20;
const int key = 30;
const int data = 40;
htable ht;
htable_init(&ht, size);
htable_insert(&ht, key, data);
htable_insert(&ht, key+1, 22);
htable_insert(&ht, key+2, 23);
htable_insert
浏览 2提问于2017-03-13得票数 2
回答已采纳
2回答
我有一个基本的疑问，当我们取消引用指向数组的指针时，为什么我们得到数组的名称而不是数组的第一个成员的值，我看到这里有人问过这个问题，但是我没有确切地得到它是如何得到的？
main()
{
int var[10] = {1,2,3,4,5,6,7,8,9,10};
int (*ptr) [10] = &var;
printf("value = %u %u\n",*ptr,ptr); //both print 2359104. Shouldn't *ptr print 1?
}
那么，当我们取消引用一个指针时，它取消了引用操作符，得
浏览 5提问于2022-08-10得票数 0
2回答
拿着这个
char array1[10][10];
能否得到array1的地址？我可以用哪种类型的货呢？已经尝试了以下几点：
char *hold[10][10];
hold = &array1;
但不起作用，想法？
浏览 2提问于2017-02-20得票数 0
回答已采纳
4回答
请看下面的代码：
#include <stdio.h>
void main()
{
int a=30;
int *var=&a;
Change(&var);
printf("%d %d",*var,a);
}
int Change(int**ptr)
{
**ptr=40;
}
#include <stdio.h>
void main()
{
int a=30;
int *var=&a;
Change(var);
printf("%d %d&
浏览 5提问于2016-07-06得票数 0
回答已采纳
在下面的代码中，我声明了一个int数组"a“，然后声明了指向整个数组”ap“的指针：
int main(){
int a[3] = {10, 100, 1000};
int (*ap)[] = &a;
printf("%p\n", ap);
printf("%p\n", *ap);
printf("%d\n", **ap);
return 0;
}
ap的第一次打印显示它实际上是指向数组的第一个值的指针。好的。
但是在第二次打印中，
浏览 10提问于2022-09-07得票数 5
回答已采纳
4回答
我想知道数组在c中是如何工作的，我最终得出了一个假设，我想知道我的假设是否正确。
我们知道数组是一系列相邻的内存盒(盒子)，其中每个盒子都有它存储的类型的大小(即，如果整数，一个盒子的大小= sizeof(int)，一个由3个int组成的数组在内存中的相邻位置为3sizeof(Int))
现在我们还知道，我们可以为某个类型的数组动态分配内存(C中的malloc，C++中的新特性)。
让我好奇的是，一个数组的原点是数组的第一个框的地址，当用括号调用它时，第一个值(后一个框中的值)是数组类型*(array+0)数组*数组(数组是被声明为“类型*数组”、“类型数组”还是“类型数组”)，而这样调用的“
浏览 2提问于2013-10-15得票数 23
回答已采纳
5回答
我一直在阅读指针是如何在C++中工作的，我试着把它搞得一团糟，但是程序停止了工作。
#include <iostream>
using namespace std;
int main ()
{
char a[] = "Hello";
char * b = a;
char ** c = &b;
cout << *(b+1) << endl;
//cout << **(c+2) << endl;
return 0;
}
如果未注释注释行，程序将停止使用错误代码: 0xC0000005。是
浏览 5提问于2015-12-29得票数 2
回答已采纳
1回答
请看下面的代码。
GameComponent.h
#pragma once
#include<time.h>
#include "Position.h"
class GameComponent
{
public:
GameComponent(int);
GameComponent();
~GameComponent(void);
virtual void update(const tm*);
void addPosition(Position *p);
friend class Position;
priva
浏览 3提问于2012-12-21得票数 1
3回答
用指针算法计算数组长度
、、、、
我想知道*(&array + 1)到底是如何工作的。我认为这是计算数组长度的一种简单方法，并希望在使用它之前正确地理解它。我对指针算法不是很熟悉，但根据我的理解，&array给出了数组的第一个元素的地址。(&array + 1)将以地址的形式到达数组的末尾。但是*(&array + 1)不应该给出这个值，它位于这个地址。而是打印地址。我真的很感激你帮我弄清楚我脑子里的指针。
下面是我正在做的一个简单的例子：
int numbers[] = {5,8,9,3,4,6,1};
int length = *(&numbers + 1) - numbers;
浏览 1提问于2018-10-09得票数 12
回答已采纳
1回答
我用C语言编写了一个程序来计算矩阵的SVD，使用Jacobi的算法。我在程序中有三个函数:一个叫做jacobi_helper的函数，它将执行SVD，一个叫做jacobi的函数，它在初始化几个数组之后调用jacobi_helper，以及主函数调用jacobi。
我的问题在于，在jacobi_helper中，似乎正确地执行了SVD，但是这些值似乎没有返回到jacobi，即使它们是在一个空函数中传递的。最后，我试图打印SVD的矩阵U和V，以及奇异值的向量。我的困惑是，奇异值的向量能够很好地打印，但矩阵不能打印。
这是我的代码：
#include <stdio.h>
#in
浏览 3提问于2015-03-07得票数 0
回答已采纳
2回答
#include <stdio.h>
int main() {
int op9=9;
int op99=99;
int op999=999;
int op9999=9999;
int *ptr1=&op9,*ptr2=&op99,*ptr3=&op999,*ptr4=&op9999;
*ptr1++;
++*ptr2;
(*ptr3)++;
*++ptr4;
printf("%d=ptr1 \t %d=ptr2 \t %d=ptr3 \t %d=ptr4&
浏览 2提问于2014-09-13得票数 3
回答已采纳
2回答
为什么即使我已经用*a[1]=1;在堆上为它分配了空间，我还是得到了一个段错误错误？
void d(int **a, int count){
*a = malloc(sizeof(int)*count);
*a[1]=1;
}
int main(){
int count =10;
int *a;
d(&a, count);
}
浏览 0提问于2017-09-30得票数 1
2回答
我想我会更好地理解这个概念，如果有人能帮助我在当前的项目，我正在工作。我想使用C来编辑特定内存地址的数据，使用指针。具体来说，我有两个字符数组(字符串)，我既需要在特定位置读取数据，也需要在特定位置写入数据。
我主要对指针的语法感到困惑，比如*、->和&。
据我理解，*指的是保存在指针当前内存地址上的数据。因此，例如，如果我想在char *p的开始内存地址编辑数据，我将执行如下操作：(*p) = 'c';
现在，如果我想从p的开头更改第二个内存地址的字符，该怎么办？
另外，我理解&是指指针的位置。但我不知道如何使用这个语法。
以下是我的例子：
int
浏览 1提问于2013-02-09得票数 0
这是源代码
int main()
{
int s[4][2]={
{1,2},
{3,4},
{5,6},
{7,8},
};
printf("%d\n",*(s+2);
return 0;
}
上面的代码是打印s2或(s+2)数组的基地址，即元素5的地址，但是为什么它没有打印值5。
浏览 5提问于2014-01-14得票数 2
回答已采纳
我试图得到一个不允许直接引用的值的地址。
int main() {
int a = {1, 2, 3, 4};
int* ptr = &arr[0];
// ptr is incremented an unknown number of times
}
在指针移动未知次数之后，我需要知道指针所指向的值的地址。假设*ptr现在是3，我需要知道3的地址，而不引用数组。有可能吗？
浏览 9提问于2022-10-10得票数 0
回答已采纳
2回答
考虑以下C++伪码：
// Pointer to contiguous memory block suitably aligned to contain
// an array of type T. Possibly obtained via std::malloc or std::aligned_storage.
void *buffer = ...;
// Now cast as T pointer.
T *ptr = static_cast<T *>(buffer);
// Do some pointer arithmetics. For instance, construc
浏览 5提问于2013-07-24得票数 3
2回答
如果我把这个写在C里，
int a[50];
我使用a，它实际上指向数组的第一个元素的地址。
但是，如果我有int b[10][10]，并且使用b或b[0]，那么它将指向什么呢？
第二，如果我知道，
`&a[0]`
这基本上给出了第一个元素的地址，但是如果我这样做了，&a，这实际上意味着什么？还有像&a + 1这样的操作。基本上，我们是在计算数组的第一个元素的地址吗？
或者说，如果我有一个3d数组，int c[10][10][10]，那么c意味着什么？它将指向哪个元素？或者，如果我这样做了，c[0]+1，这将指向数组的哪个部分？
谢谢!
浏览 1提问于2014-07-20得票数 1
回答已采纳
我阅读了，也进行了搜索，但我找不到一种用ctype声明这种结构的方法。这个结构是由我为其编写Python接口的函数返回的。
typedef struct{
int i;
float *b1;
float (*w1)[];
}foo;
这就是我到目前为止所知道的：
class foo(Structure):
_fields_=[("i",c_int),
("b1",POINTER(c_int)),
("w1",?????????)]
谢谢你的帮忙!
浏览 4提问于2010-06-25得票数 1
回答已采纳
2回答
我理解一维数组指针是如何工作的，但我不知道2D数组指针是如何工作的。
我知道array1 == *(array1 + 0)，但是我不知道如何在2D数组中使用这种形式。我发现如果我使用双指针或‘[]’(我不知道这是什么)，那么它就能工作了。
如何使用指针访问多维数组？
可以使用双指针还是“[]”？如果是的话，为什么？？
和为什么*(2 2Darrayname+ number)不能工作？
是因为腐朽什么的吗？(我不知道什么是腐朽的东西)
)我已经检查了这些
int main()
{
int array1[5];
int array2[5][5];
f1(array1)
浏览 5提问于2021-05-15得票数 0
回答已采纳
4回答
#include<stdio.h>
int main()
{
char *str1 = "computer";
printf ("%p\n", (void *) str1); // i
printf ("%p\n", (void *) &str1); // ii
printf ("%d\n", *str1); // iii
printf ("%p\n", (void *) *&str1); // iv
printf (&
浏览 4提问于2014-07-17得票数 4
4回答
所以我试着理解两件事：
这三种表达方式有什么不同？
第一个表达式(A)的等价性是什么？
下面是代码(固定的)：
#include "stdafx.h"
void someFunc(double** pArray, int length)
{
for(int i = 0; i < length; i++)
{
//this works perfectly
double expressionA = *(*pArray + i);
//this crashes : Unhandled except
浏览 1提问于2011-05-12得票数 1
回答已采纳
2回答
我尝试了下面的代码
#include<stdio.h>
int main()
{
int A[3][4] = {{1,2,3,4},{5,6,7,8,},{9,10,11,12}};
int **t = &A[0]; //I do this or **t = A,I guess both are equivalent
printf("%d %p\n\n",*t,A[0]);
return 0;
}
我想要发生的事情：
现在t是一个2d指针(指向指针的指针)，它持有A的地址，而A的地址又是A的地址。所以*t应该给我A
浏览 0提问于2013-04-13得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
