1. 指针和数组 1 晚.

正如在所有 数组 我们知道我们可以将其看作是一个变量数组指针, 这样我们就可以使用数组变量来访问指针方式阵列.

//code by nguyenvanquan7826
#include <stdio.h>

void nhapMang(int a[], int n) 
{
    int i;
    for (i = 0; i < n; i++) 
    {
        printf("Nhap a[%d] = ", i);
        scanf("%d", &a[i]);
    }
}

void nhapContro(int a[], int n)
{
    int i;
    for (i = 0; i < n; i++) 
    {
        printf("Nhap a[%d] = ", i);
        scanf("%d", a + i);
    }
}

void xuatMang(int a[], int n) 
{
    int i;
    for (i = 0; i < n; i++) 
    {
        printf ("%d \t", a[i]);
    }
}

int main() 
{
    // khai bao mang a co n phan tu
    int n = 5;
    int a[n];
    nhapContro(a, n);
    xuatMang(a, n);

    return 0;
}

在上述第一功能与正常打字用, 我就不多说.

在第二功能, 我们只需更换 &通过A I的声明的[20] 是一个被视为一个指针，它会分配内存单元之一行从一个到一个 + 19. 和 + i是一个地址[在] (也就是说，它等同于 &该[在]). 的指针的位置[0].

指针和数组在C中

你也可以声明 1 数组，然后使用 1 指针第一阵列，​​指针到阵列也.

//code by nguyenvanquan7826
#include <stdio.h>

int main() 
{
    int n = 5, i;
    int a[n], *pa;
    pa = a; // con tro pa tro toi dau mang a

    for (i = 0; i < n; i++) 
    {
        printf("Nhap a[%d] = ", i);
        scanf("%d", pa + i);
    }

    for (i = 0; i < n; i++) 
    {
        printf ("%d \t", *(pa + i));
    }

    return 0;
}

你已经注意到了: 为什么我们并不需要分配给指针PA内存仍然使用正常, 因为我们已经声明了一个板[20] 如果机器分配的存储单元阵列来存储, 当我们执行指针阵列的指针PA，那么存储器单元已没有必要分配更多的存储单元进行巴. 考虑下面的例子:

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    int n = 5, i;

    // cap phat bo nho cho pa
    int *pa = (int *) malloc(n * sizeof(int));

    for (i = 0; i < n; i++) 
    {
        printf("Nhap a[%d] = ", i);
        scanf("%d", pa + i);
    }

    for (i = 0; i < n; i++) 
    {
        printf ("%d \t", *(pa + i));
    }

    return 0;
}

在这个例子中，我们都没有声明为VD前数组中, 所以也不能指向任何位置PA, 但想要做的是，我们需要分配存储单元这样的PA.

2. 输入功能阵列

阵列条目并不总是有利的，因为如前面的例子，我们需要有数组元素的数目之前分配或导入, 所以，如果我们不知道提前元素，用户必须输入阵列功能，星星数量. 你看下面的例子.

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

void nhapContro(int *(*a), int *n) 
{
    int i;

    printf("Nhap so phan tu cua mang: ");
    scanf("%d", n); // khong phai &n
    *a = (int *) malloc ((*n) * sizeof(int));
    // *a : lay dia chi cua mang a chu khong phai gia tri cua a

    for (i = 0; i < *n; i++) 
    {
        printf("Nhap a[%d] = ", i);
        scanf("%d", (*a + i));
    }
}

void xuatMang(int *a, int n) 
{
    int i;
    for (i = 0; i < n; i++) 
    {
        printf ("%d \t", a[i]);
    }
}

int main() 
{
    int *a, n;

    nhapContro(&a, &n); // lay dia chi cua a va n
    xuatMang(a, n);

    return 0;
}

在这个例子中，我们进行的输入和输出功能的数组, 内存分配函数也是. 在节目的标题和说明.

有 1 一点要注意，该函数通过输入一个指针数组，也 2 迹象 *. 1 是阵列的标志 (编号 2), 第一符号也用来传送地址数组的值，可以保持从颚的, 它就像一个标志 * 在功能上 HoanVi(INT *该,INT * B) 所以.

3.指针和字符串

由于性质和特性的字符串是字符数组所以这是类似于阵列 1 晚, 我会说了 1 一点 1 简单的例子.

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    char *name;
    name = (char *) malloc (100*sizeof(char));

    printf("What your name? ");
    gets(name);

    printf("Oh, Hello %s\n", name);

    return 0;
}

4. 指针和数组 2 晚, 指针数组 - 光标多级

该. 指针和数组 2 晚

上半部分，我们了解指针和数组 1 晚, 而这部分指针和数组 2 方式类似于.

我们知道，计算机存储器阵列存储的本质 2 维数组一样 1 晚. 所以，我们完全可以执行数组 2 像指针维数组 1 晚.

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    double a[10][10], *pa;
    int n, m, i;
    pa = (double *) a;
    printf("Nhap so hang va so cot:\n");
    scanf("%d %d", &n, &m);

    for (i = 0 ; i < n * m; i++) 
    {
        printf("Nhap a[%d][%d] = ", i / m, i % m);
        scanf("%lf", pa + i);
    }

    for (i = 0 ; i < n * m; i++) 
    {
        if (i % m == 0) printf("\n"); // xuong dong
        printf("%-5.2lf", *(pa + i));
    }

    return 0;
}

结果:

输入的行数和列数:
2
3
导入[0][0] = 4.23
导入[0][1] = 5.7
导入[0][2] = 1.2
导入[1][0] = 8.6
导入[1][1] = 3.456
导入[1][2] = 12

4.23 5.70 1.20
8.60 3.46 12.00

而且, 我们可能甚至不需要使用PA是 1 指针. 或者你可以输入 1 以同样的方式作为阵列 2 如下正常途径.

你注意为什么我们有 然而， + 在*10 + Ĵ. 这是因为主要功能() 我声明 a[10][10] 应的机器分配给我们的存储单元阵列 2 尺寸的 10 排, 10 列的，如果我们没有用完它仍然存在.

指针和数组 2 C语言的方式

你有没有注意到，我们可以写一个[在][Ĵ] 但 不能写PA[在][Ĵ] 自从宣布它牌匾 2 下午，这样我们就可以写出这么有PA 1 光标当我们分配PA = A，我们认为是一个默认的数组 1 晚. 因此，如果我们只允许写PA[在10+Ĵ] (取值) 和 &然而，[在10+Ĵ] (获取IP地址).

B. 指针数组

指针数组是含有一组指针相同类型的数组.
浮动*一[10]; // 声明一个指针数组. 含 10 指针: 该[0], 该[1], …一个[9]; 是 10 指针.
联系板块 2 这样，我们有以下的意见: 所述阵列的每一行 2 下午我， 1 板 1 晚. 每个指针，然后与关系 1 板 1 晚, 我估计:

指针和数组 2 C语言的方式

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    double a[10][10], *pa[10];
    int n, m, i, j;

    printf("Nhap so hang va so cot: ");
    scanf("%d %d", &n, &m);

    for (i = 0 ; i < n; i++) 
    {
        pa[i] = a[i]; // con tro thu i tro den hang thu i
        for (j = 0 ; j < m; j++) 
        {
            printf("Nhap a[%d][%d] = ", i, j);
            scanf("%lf", &pa[i][j]);
        }
    }

    for (i = 0 ; i < n; i++) 
    {
        printf("\n"); // xuong dong
        for (j = 0 ; j < m; j++) 
        {
            printf("%-5.2lf", pa[i][j]);
        }
    }

    return 0;
}

我写在本实施例的原因是巴[在][Ĵ] 这是因为各为Pa 1 指针的一维数组. 然而，[在][Ĵ] 也就是说，指针PA的第j个要素[在].

上面的例子，我们认为是一个声明数组[][] 应该不需要分配内存的指针, 现在想分配内存的指针数组 2 像分配维数组 1 这样，我们做了以下:

//code by nguyenvanquan7826
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    double **pa;
    int n, m, i, j;

    printf("Nhap so hang va so cot: ");
    scanf("%d %d", &n, &m);

    // cap phat n o nho cho n con tro (n hang)
    pa = (double**) malloc(n * sizeof(double));

    for (i = 0 ; i < n; i++) 
    {
        // cap phat m o nho cho moi con tro (moi hang)
        pa[i] = (double *) malloc(m * sizeof(double));
        for (j = 0 ; j < m; j++) 
        {
            printf("Nhap a[%d][%d] = ", i, j);
            scanf("%lf", &pa[i][j]);
        }
    }

    for (i = 0 ; i < n; i++) 
    {
        printf("\n"); // xuong dong
        for (j = 0 ; j < m; j++) 
        {
            printf("%-5.2lf", pa[i][j]);
        }
    }

    return 0;
}

它可以被看作一个指针数组, 或一个指向指针的指针 (多级指针).