Question

请帮助我理解以下程序。

#include<stdio.h>
int main()
{
    int a[7];
    a[0] = 1976;
    a[1] = 1984;
    printf("memory location of a: %p", a); 
    printf("value at memory location %p is %d", a, *a); 
    printf("value at memory location %p is %d", &a[1], a[1]);
    return 0;
}

&a[1]和&a+1。它们是相同还是不同？

#include <stdio.h> 
int main() 
{
    int v[10];
    int **p; 
    int *a[5];
    v[0] = 1234;
    v[1] = 5678;
    a[0] = v; 
    a[1] = v+1;
    printf("%d\t%d\t%d\t%d\n", *a[0],*a[1],a[0][0],**a);
    printf("%d\n", sizeof(v));
    return 0;
}

我想知道*a[5]如何在记忆中表现出来。 *a是指向a[0],a[1],a[2],a[3],a[4]的基本指针吗？

#include<stdio.h>

int main()
{
    int v[10];
    int **p;
    int (*a)[10];
    a=&v;
    printf("%d\n",*a);
        return 0;
}

a=v; // gives error why?这里v会衰变为*v。那么&v会变为(*)[]v吗？＆安培;意味着const指针。如何在没有类型转换的情况下如何将const指针设置为非const指针？

数组在哪里存储在内存中。它是否存储在内存的数据段中。

#include<stdio.h>

int main()
{
    int carray[5]={1,2,3,4,5};
    printf("%d\n",carray[0]);
    printf("%d\t%d\t%d\n",sizeof(carray),sizeof(&carray),sizeof(&carray[0]));
    return 0;
}

编辑：

我已经阅读了一些文章，其中指出数组名称不能被指定为指针的唯一两种可能情况是sizeof和&。但是在上面的程序sizeof(&carray)中，大小为4. &carray衰减为(*)[]carray作为右值。

然后，数组名称无法在两个条件sizeof和&上变为指针的语句在此处变为false。

Answer 1

&a[1]和&a+1。它们是相同还是不同？

不同。 &a[1]与(a+1)相同。一般来说，x[y]的定义相当于*(x+y)。

我想知道*a[5]如何在记忆中表现出来。 *a是否为基础指向a[0],a[1],a[2],a[3],a[4]的指针。

在第二个示例中，a是一个指针数组。 *a[i]是对象的值，其地址存储为数组中的i ^th元素。在这种情况下，*a与a[0]相同，a=v //why this gives error是数组中的第一个元素（它是一个指针）。

a

因为a（在上一个示例中）是指向数组的指针。您想要分配到v，那么您需要分配数组a = &v;的地址（或任何其他具有正确尺寸的数组）;

{{1}}

这是非常好的，你已经承诺了解事情，但没有什么比a good C book更能帮助你。

希望这有帮助。

Answer 2

你在处理指针时需要知道的是：

int *a and int a[]

是一个Array的声明，唯一的不同之处在于，在[]中你必须声明它的常量大小，* a给你灵活性，它可以指向一个数组大小为1到无穷大

int *a[] and int **a

是一个数组Array的声明，有时也称为Matrix，唯一的不同就是* a []你必须声明有多少数组a []将包含指针，** a给你灵活性，它可以指向您希望将其分配给的任何数组数组。

总的来说：添加＆amp;对于变量，您在其类型定义中添加*：

int a;

＆amp; a - ＆gt;及（INT）= INT *

将*添加到变量时，您从其类型定义

中删除*

int * a;

* a - ＆gt; *（int *）= int

int *a;
&a - the Address given to the pointer a by the system(pointer of pointer = **a)
&a+1 - the Address to the beginning of the array + 1 byte
&a[1] == &(a+1) - the Address to the beginning of the array + 1 size of int

int **a;
*a == a[0] - the Address of the first Array in the array of arrays a
*a[0]==a[0][0] - the first int of first array

int *a, b[5];
*a=*b - ERROR because a points at garbage to begin with
a=b - a points at array b

问我还想知道什么，编辑这个答案。

Answer 3

＆amp; a [1]和＆amp; a + 1。它们是相同还是不同？

不是它们不是，第一个引用数组中的第二个整数，称为a，第二个引用从sizeof（int）字节构建的整数，从内存位置开始，位于+ 1个字节。

我想知道* a [5]如何在内存中表示。* a *是一个基础指向[0]，[1]，a [2]，a [3]，a [4]的指针。

a现在是指向您在大小为5的堆栈上声明的数组中第一个元素的位置的指针。＆amp; a指向与＆amp; a [0]相同的东西; ＆amp; a [1]指向＆amp; a + sizeof（int）。

A = V; //给出错误原因？在这里v衰变成* v。

这会给你一个错误，因为a是指向数组的指针而v是数组。因此，您必须将v（＆amp; v）的地址分配给。

这里v衰变成* v

数组永远不会衰落到它的第一个元素。决不。 v可以拒绝&v[0]（与&*v相同），但永远不会v[0]（或*v，这是相同的）

数组衰减成指针

3 个答案: