C语言中指针与数组的关系

我有3个来自CLA认证（C编程语言认证助理认证；CPP研究所）的案例，我想更好地理解：

int*数组[10]

int（*array）[10]

int*（*数组）[10]

这三种情况之间有什么区别？

以下是您的情况：

指向

int

的10个指针的数组

指向10

int

数组的指针

指向指向

int

的10个指针数组的指针

这个

是包含10个

int*

类型元素的数组的声明

这是一个演示程序

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * array[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *array[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int (*array)[N] = &a;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", ( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * b[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    int *(*array)[N] = &b;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

这个

是指向数组类型为

int[10]

的对象的指针声明

这里是另一个演示程序

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * array[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *array[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int (*array)[N] = &a;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", ( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * b[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    int *(*array)[N] = &b;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

这个

是指向数组类型

int*[10]

的对象的指针声明

这里还有一个演示程序

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * array[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *array[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int (*array)[N] = &a;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", ( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * b[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    int *(*array)[N] = &b;

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", *( *array )[i] );
    }
    putchar( '\n' );

    return 0;
}

通常，如果您有一个数组，例如

T a[N1][N2][N3];

如果

T

是某种类型说明符，

N1

，

N2

，

N3

是它的大小，那么指向这样一个数组的指针如下所示

T ( *p )[N1][N2][N3] = &a;

取消对指针的引用将获得数组本身的lavlue

比如说

sizeof（*p）

等于

sizeof（a[N1][N2][N3]）

下面是一个更复杂的声明示例

int * ( * array[10] )[10];

它是指向类型

int

的10个指针元素数组的10个指针元素数组的声明

下面是一个演示程序，演示如何处理这样的数组。调查它。：）

---

是的，对不起，我看错了。显然，“一个指向10

int*

数组的指针”更容易阅读。@Lundin好吧，我把它完全扩展成了英语。离开

int*

将是一个不完整的扩展。这是描述它的标准方式，不使用任何括号或括号或星号，即完全用英语。也许只是我的C语言比英语更流利：）@Lundin是的，英语描述很麻烦。我只在人们需要声明的英语描述时才使用它们。我建议阅读第6节。这是否回答了你的问题？

#include <stdio.h>

int main(void) 
{
    enum { N = 10 };
    int a[N] = 
    { 
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9 
    };

    int * b[N] = 
    { 
        &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9] 
    };

    int * ( * array[N] )[N] = 
    { 
        &b, &b, &b, &b, &b, &b, &b, &b, &b, &b
    };

    for ( size_t i = 0; i < N; i++ )
    {
        for ( size_t j = 0; j < N; j++ )
        {
            printf( "%d ",  ( **array[i] )[j] );
        }           
        putchar( '\n' );
    }
    putchar( '\n' );

    return 0;
}

0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 5 6 7 8 9