C++ 指针数组

数组和指针是紧密相关的。在C++中，数组的名称被视为指针，即数组的名称包含元素的地址。C++将数组名称视为第一个元素的地址。例如，如果我们创建一个数组，即存储20个整数类型值的marks数组，则marks将包含第一个元素marks[0]的地址。因此，我们可以说数组名（marks）是一个指针，它保存着数组第一个元素的地址。

让我们通过一个例子来理解这种情况。

#include <iostream>
using namespace std;
int main()
{
    int *ptr;  // integer pointer declaration
    int marks[10]; // marks array declaration
    std::cout << "Enter the elements of an array :" << std::endl;
    for(int i=0;i<10;i++)
    {
        cin>>marks[i];
    }
    ptr=marks; // both marks and ptr pointing to the same element..
    std::cout << "The value of *ptr is :" <<*ptr<< std::endl;
    std::cout << "The value of *marks is :" <<*marks<<std::endl;
}

在上面的代码中，我们声明了一个整数指针和一个整数类型的数组。我们使用语句ptr=marks将marks的地址赋值给ptr，这意味着变量’marks’和’ptr’都指向同一个元素，即marks[0]。当我们尝试打印ptr和marks的值时，它们是相同的。因此，证明了数组名存储了数组的第一个元素的地址。

输出

C++ 指针数组

指针数组

指针数组是由指针类型的变量组成的数组，这意味着变量是指针，它指向其他元素。假设我们创建一个包含5个整数指针的指针数组，它的声明将如下所示：

int *ptr[5];         // array of 5 integer pointer.

在上面的声明中，我们声明了一个名为ptr的指针数组，并分配了5个整数指针的内存。

指针数组的元素也可以通过分配某个其他元素的地址来进行初始化。让我们通过一个例子观察这种情况。

int a; // variable declaration.
ptr[2] = &a

在上面的代码中，我们将’a’变量的地址分配给数组’ptr’的第三个元素。

我们也可以通过解引用指针来获取’a’的值。

*ptr[2];

让我们通过一个例子来理解。

#include <iostream>
using namespace std;
int main()
{
    int ptr1[5]; // integer array declaration
    int *ptr2[5]; // integer array of pointer declaration
    std::cout << "Enter five numbers :" << std::endl;
    for(int i=0;i<5;i++)
    {
        std::cin >> ptr1[i];
    }
    for(int i=0;i<5;i++)
    {
        ptr2[i]=&ptr1[i]; 
    }
    // printing the values of ptr1 array
    std::cout << "The values are" << std::endl;
    for(int i=0;i<5;i++)
    {
        std::cout << *ptr2[i] << std::endl;
    }
    }

在上面的代码中，我们声明了一个整数类型的数组和一个整型指针数组。我们定义了一个“for”循环，它遍历数组“ptr1”的元素，并且在每次迭代中，将ptr1的索引’i’处元素的地址存储在ptr2的索引’i’处。

输出：

C++ 指针数组

目前为止，我们已经学习了指向整数的指针数组。现在，我们将看到如何创建指向字符串的指针数组。

指向字符串的指针数组

指向字符串的指针数组是一个字符指针的数组，它保存了字符串的第一个字符的地址，也可以说是字符串的基地址。

指向字符串的指针数组和二维字符数组之间的区别如下：

指向字符串的指针数组在内存消耗方面比二维字符数组更高效，因为指向字符串的指针数组比二维字符数组消耗更少的内存来存储字符串。
在指向字符串的指针数组中，字符串的操作比2D数组更容易。我们还可以通过使用指针轻松更改字符串的位置。

让我们看看如何声明指向字符串的指针数组。

首先，我们声明一个指向字符串的指针数组：

char *names[5] = {"john",
                  "Peter",
                  "Marco",
                  "Devin",
                  "Ronan"};

在上面的代码中，我们声明了一个名为’names’的指针数组，大小为5。在上面的情况下，我们在声明时初始化，所以不需要提及指针数组的大小。上面的代码可以重写为：

char *names[ ] = {"john",
                  "Peter",
                  "Marco",
                  "Devin",
                  "Ronan"};

在上述情况中，’names’数组的每个元素都是一个字符串字面量，而每个字符串字面量都将保存一个字符串的第一个字符的基地址。例如，names[0]包含了”john”的基地址，names[1]包含了”Peter”的基地址，依此类推。并不能保证所有的字符串字面量都将存储在连续的内存位置，但是一个字符串字面量的字符是存储在连续的内存位置上的。

让我们创建一个简单的例子。

#include <iostream>
using namespace std;
int main()
{
  char *names[5] = {"john",
                    "Peter",
                    "Marco",
                    "Devin",
                    "Ronan"};
for(int i=0;i<5;i++)
    {
        std::cout << names[i] << std::endl;
    }
    return 0;
}

在上面的代码中，我们声明了一个包含5个字符串文字的char指针数组，每个字符串的第一个字符保存了字符串的基地址。

输出

C++ 指针数组