c++入门----适用于初学者（7）----数组、字符串和指针

目录

数组、字符串和指针

数组

访问数组

多维数组

C-style 字符串

字符串

指针

指针的赋值与使用

引用

总结

---

数组、字符串和指针

数组

C++ 中的数组是一种存储固定大小、相同类型元素的数据结构。它可以按照索引访问其中的元素，并且具有连续的内存布局。

以下是定义和使用数组的一些基本步骤：

1. 声明数组：在 C++ 中，声明一个数组需要指定元素的类型和数组的名称。例如，int 类型的整数数组可以声明为：int myArray[5];，这里 myArray 是数组名，5 表示数组的大小，即元素数量。

2. 初始化数组：可以使用大括号 {} 来初始化数组的元素。例如，int myArray[5] = {1, 2, 3, 4, 5}; 将数组的前 5 个元素分别初始化为 1、2、3、4、5。如果不提供足够的初始值，将使用默认值进行初始化。

3. 访问数组元素：可以使用索引来访问数组中的元素。数组的索引从 0 开始，因此第一个元素的索引是 0，第二个元素的索引是 1，依此类推。例如，int x = myArray[2]; 将把数组 myArray 的第三个元素赋值给变量 x。

4. 修改数组元素：可以通过索引对数组中的元素进行修改。例如，myArray[3] = 10; 将把数组 myArray 的第四个元素修改为 10。

5. 数组遍历：可以使用循环结构来遍历数组中的所有元素，并对每个元素进行操作。常用的循环结构有 for 循环和 while 循环。

以下是一个示例代码，展示了数组的声明、初始化和遍历过程：

#include <iostream>
using namespace std;

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};

    // 遍历数组并输出各元素的值
    for (int i = 0; i < 5; i++) {
        cout << myArray[i] << " ";
    }
    cout << endl;

    return 0;
}

以上示例中，定义了一个包含 5 个整数的数组 myArray，并将元素初始化为 1、2、3、4、5。然后使用 for 循环遍历数组，依次输出各元素的值。

需要注意的是，C++ 中的数组索引越界会导致未定义的行为，因此在使用数组时要确保索引值在合法范围内。此外，C++ 也提供了许多与数组相关的库函数和操作，如求和、排序等，可以根据需要进行使用。

访问数组

在 C++ 中，可以使用索引访问数组中的元素。数组的索引从 0 开始，因此第一个元素的索引是 0，第二个元素的索引是 1，依此类推。

以下是通过索引访问数组元素的示例代码：

#include <iostream>
using namespace std;

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};

    // 访问数组元素并输出
    cout << "First element: " << myArray[0] << endl;
    cout << "Second element: " << myArray[1] << endl;
    cout << "Third element: " << myArray[2] << endl;
    cout << "Fourth element: " << myArray[3] << endl;
    cout << "Fifth element: " << myArray[4] << endl;

    return 0;
}

在上述示例中，定义了一个包含 5 个整数的数组 myArray，并将元素初始化为 1、2、3、4、5。然后通过索引访问每个元素，并使用 cout 输出到控制台。

输出结果为：

First element: 1
Second element: 2
Third element: 3
Fourth element: 4
Fifth element: 5

请注意，访问数组时要确保索引值在合法范围内，即不能超过数组的长度减一。否则会导致访问越界，可能会引发未定义的行为或错误。

多维数组

在 C++ 中，多维数组是一种包含多个维度的数组结构。它可以用来表示矩阵、表格或其他更复杂的数据结构。

C++ 支持二维及以上的多维数组。以下是创建和访问二维数组的基本步骤：

1. 声明多维数组：声明一个多维数组需要指定每个维度的大小。例如，要声明一个 3x3 的整数二维数组，可以使用以下语法：int myArray[3][3];，这里 myArray 是数组名，3 表示第一维的大小，另一个 3 表示第二维的大小。

2. 初始化多维数组：可以使用嵌套的大括号 {} 来初始化多维数组的元素。例如，int myArray[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; 将二维数组的每个元素分别初始化为 1 到 9。请确保提供足够的初始值以匹配数组的维度。

3. 访问多维数组元素：可以使用多个索引来访问多维数组中的元素。每个索引对应一个维度。例如，要访问二维数组 myArray 的第二行第三列的元素，可以使用 myArray[1][2]。注意，索引仍然从 0 开始。

以下是一个示例代码，展示了二维数组的声明、初始化和访问过程：

#include <iostream>
using namespace std;

int main() {
    int myArray[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    // 访问二维数组元素并输出
    cout << "Element at (0, 0): " << myArray[0][0] << endl;
    cout << "Element at (1, 2): " << myArray[1][2] << endl;
    cout << "Element at (2, 1): " << myArray[2][1] << endl;

    return 0;
}

在上述示例中，定义了一个 3x3 的整数二维数组 myArray，并将元素初始化为 1 到 9。然后通过多个索引访问每个元素，并使用 cout 输出到控制台。

输出结果为：

Element at (0, 0): 1
Element at (1, 2): 6
Element at (2, 1): 8

类似地，你可以定义更高维度的多维数组，并使用相应数量的索引来访问各个维度的元素。

C-style 字符串

C-style 字符串是一种以字符数组形式表示的字符串，在 C++ 中通过以空字符 '\0' 结尾来表示字符串的结束。

以下是使用 C-style 字符串的基本操作：

1. 声明和初始化：C-style 字符串使用字符数组来存储字符串。例如，char str[6] = "Hello"; 声明一个长度为 6 的字符数组 str，并将其初始化为 "Hello"。注意数组长度必须足够容纳字符串的字符数量加上结尾空字符。

2. 输出字符串：可以使用 cout 来输出 C-style 字符串，它会自动遍历字符数组直到遇到空字符 '\0'。例如，cout << str; 将输出字符数组 str 中的字符串内容。

3. 字符串函数：有很多字符串处理函数可以用于 C-style 字符串。例如，strlen() 可以返回字符串的长度，不包括结尾空字符；strcpy() 可以将一个字符串复制到另一个字符串；strcat() 可以将一个字符串连接到另一个字符串末尾。

以下是一个示例代码，展示了使用 C-style 字符串的基本操作：

#include <iostream>
#include <cstring> // 包含字符串处理函数的头文件
using namespace std;

int main() {
    char str[6] = "Hello";

    // 输出字符串
    cout << "String: " << str << endl;

    // 计算字符串长度
    cout << "Length: " << strlen(str) << endl;

    // 复制字符串
    char str2[6];
    strcpy(str2, str);
    cout << "Copied string: " << str2 << endl;

    // 连接字符串
    char str3[12] = "Hello";
    strcat(str3, " World!");
    cout << "Concatenated string: " << str3 << endl;

    return 0;
}

在上述示例中，定义了一个长度为 6 的字符数组 str，并将其初始化为 "Hello"。然后使用 cout 输出字符串内容和字符串长度。接着，将字符串 str 复制到另一个字符数组 str2 中，并输出复制后的字符串。最后，将字符串 " World!" 连接到字符数组 str3 的末尾，并输出连接后的字符串。

输出结果为：

String: Hello
Length: 5
Copied string: Hello
Concatenated string: Hello World!

请注意在使用 C-style 字符串时要注意数组越界和空字符 '\0' 的存在，以避免潜在的错误或问题。

字符串

在C++中，字符串可以使用std::string类来表示和操作。std::string是C++标准库提供的一个字符串类，它提供了丰富的成员函数和操作符用于处理字符串。

以下是使用std::string的一些基本操作：

1. 声明和初始化：可以使用不同的方式声明和初始化std::string对象。例如：

   std::string str1 = "Hello"; // 使用赋值初始化
   std::string str2("World"); // 使用构造函数初始化
   std::string str3; // 默认构造函数，创建一个空字符串
   

2. 访问和修改字符串：可以使用下标运算符 [] 或者 at() 成员函数来访问和修改字符串的特定位置的字符。例如：

   std::string str = "Hello";
   
   char ch1 = str[0]; // 获取字符串第一个字符
   char ch2 = str.at(1); // 获取字符串第二个字符
   
   str[0] = 'M'; // 修改字符串第一个字符
   str.at(1) = 'Y'; // 修改字符串第二个字符
   

3. 连接字符串：可以使用 + 操作符或者 append() 成员函数来连接两个字符串。例如：

   std::string str1 = "Hello";
   std::string str2 = " World";
   
   std::string result1 = str1 + str2; // 使用 + 操作符连接字符串
   std::string result2 = str1.append(str2); // 使用 append() 成员函数连接字符串
   

4. 获取字符串长度：可以使用 length() 或者 size() 成员函数来获取字符串的长度。例如：

   std::string str = "Hello";
   
   int length1 = str.length(); // 获取字符串长度
   int length2 = str.size(); // 获取字符串长度
   

5. 字符串比较：可以使用==、!=、<、>、<=、>=等操作符进行字符串的比较。例如：

   std::string str1 = "Hello";
   std::string str2 = "World";
   
   bool equal = (str1 == str2); // 比较两个字符串是否相等
   bool lessThan = (str1 < str2); // 比较字符串的字典顺序
   

以上只是std::string类的一些基本操作，还有很多其他成员函数可以用于字符串的处理，如查找子串、截取子串、插入字符等等。

需要注意的是，为了使用std::string类，你需要在代码中包含头文件 <string>。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
  
    std::cout << str << std::endl;

    return 0;
}

上述示例中声明了一个std::string对象str，并将其初始化为"Hello, World!"。然后使用std::cout输出字符串内容到控制台。

输出结果为：

Hello, World!

通过使用std::string类，你可以更方便地进行字符串的操作和处理，并且不需要手动处理内存分配和释放等问题。

指针

指针是一个用于存储内存地址的变量。在 C++ 中，我们可以使用指针来访问和操作内存中的数据。

以下是一些基本的指针操作：

1. 声明指针：通过在变量名前加上 * 符号来声明一个指针变量。例如，int* ptr; 声明了一个指向整数类型的指针变量 ptr。

2. 指针赋值：可以使用 & 运算符将变量的地址赋给指针。例如，int num = 10; int* ptr = # 将变量 num 的地址赋给指针 ptr。

3. 解引用指针：使用 * 运算符可以解引用指针，获取指针指向的变量的值。例如，int value = *ptr; 将指针 ptr 指向的整数值赋给变量 value。

4. 修改指针指向的值：通过解引用指针并修改其指向的变量，可以改变该变量的值。例如，*ptr = 20; 将指针 ptr 指向的整数值修改为 20。

5. 空指针：可以使用空指针来表示一个不指向任何有效地址的指针。例如，int* ptr = nullptr; 或者 int* ptr = NULL; 都声明了一个空指针。

6. 动态内存分配：使用 new 运算符可以在堆上动态分配内存，并返回指向该内存的指针。例如，int* ptr = new int; 分配了一个整数类型的内存，并将指针 ptr 指向该内存。

7. 释放动态分配的内存：使用 delete 运算符可以释放动态分配的内存。例如，delete ptr; 释放了指针 ptr 指向的内存。

以下是一个示例代码，展示了基本的指针操作：

#include <iostream>
using namespace std;

int main() {
    int num = 10;
    int* ptr = &num;

    cout << "Value of num: " << num << endl;
    cout << "Address of num: " << &num << endl;
    cout << "Value of ptr: " << ptr << endl;
    cout << "Value pointed by ptr: " << *ptr << endl;

    *ptr = 20;
    cout << "Modified value of num: " << num << endl;

    ptr = nullptr;
    cout << "Value of nullptr pointer: " << ptr << endl;

    int* dynamicPtr = new int;
    *dynamicPtr = 30;
    cout << "Value of dynamically allocated memory: " << *dynamicPtr << endl;
    delete dynamicPtr;

    return 0;
}

上述示例中，声明了一个整数变量 num 和一个指向整数的指针 ptr。输出了 num 的值、num 的地址、ptr 的值和 ptr 指向的值。然后通过解引用 ptr 修改了 num 的值。接着将指针 ptr 设置为空指针，并输出空指针的值。最后使用 new 动态分配了一个整数内存，并将指针 dynamicPtr 指向该内存，输出动态分配的内存的值。最后使用 delete 释放了动态分配的内存。

输出结果为：

Value of num: 10
Address of num: 0x7fff5722c3a4
Value of ptr: 0x7fff5722c3a4
Value pointed by ptr: 10
Modified value of num: 20
Value of nullptr pointer: 0
Value of dynamically allocated memory: 30

需要注意，使用指针时需要遵循一些规则，如确保指针不为空（null）、避免悬空指针等，以避免错误和未定义行为。

指针的赋值与使用

指针的赋值和使用在 C++ 中非常重要。下面我将详细介绍指针的赋值和使用的几个方面。

1. 指针的赋值：可以通过以下方式将一个指针赋给另一个指针：

   int* ptr1;
   int* ptr2;
   
   // 将 ptr1 的值赋给 ptr2
   ptr2 = ptr1;
   

上述代码中，ptr2 指针获得了与 ptr1 相同的值。此时，ptr1 和 ptr2 指向同一个内存地址。

1. 解引用指针：使用解引用运算符 * 可以获取指针指向的变量的值。例如：

int num = 10;
int* ptr = # // 将 num 的地址赋给指针 ptr

cout << "Value of num: " << *ptr << endl;

上述代码中，*ptr 返回了指针 ptr 所指向的变量 num 的值。

1. 修改指针指向的值：可以通过解引用指针并修改其所指向的变量来改变该变量的值。例如：

int num = 10;
int* ptr = # // 将 num 的地址赋给指针 ptr

*ptr = 20; // 修改指针所指向的值

cout << "Modified value of num: " << *ptr << endl;

上述代码中，通过修改指针 ptr 所指向的变量 num 的值，将其修改为 20。

1. 空指针判断：在使用指针之前，可以先进行空指针判断，以避免悬空指针引发的错误。例如：

int* ptr = nullptr; // 声明一个空指针

if (ptr != nullptr) {
    // 指针不为空时执行操作
} else {
    // 指针为空时执行操作
}

上述代码中，使用条件语句判断指针 ptr 是否为空。

需要注意的是，在使用指针时要小心，确保指针指向的内存是有效的，并且遵循正确的生命周期管理（如动态分配的内存要及时释放）。同时，避免在未初始化的指针上进行解引用操作，以防止访问无效的内存地址。

引用

在C++中，引用是一种创建变量别名的方法。通过引用，我们可以使用一个变量的另一个名称来访问和修改该变量的值，而无需操作指针。引用提供了更直接、简洁的方式来处理变量别名。

下面是一些关于引用的基本知识点：

1. 引用的声明：使用 & 符号来声明一个引用。例如，int num = 10; int& ref = num; 声明了一个引用 ref，它是变量 num 的别名。

2. 引用的初始化：一旦引用被声明，它必须在初始化时与某个变量绑定。例如，int num = 10; int& ref = num; 将引用 ref 和变量 num 绑定在一起。

3. 引用与原变量的关系：引用和原变量共享相同的内存地址。对引用的任何操作都会影响到原变量。例如，如果通过引用来修改变量的值，原变量也会被修改。

4. 引用作为函数参数：引用可以用作函数的参数，使得函数能够直接修改传入的变量。这种方式比传递指针或传递副本更高效且更简洁。

5. 引用的限制：引用必须在声明时初始化，并且不能更改绑定的变量。一旦引用绑定了某个变量，它将一直与该变量相关联。

下面是一个简单的示例代码，演示了引用的声明和使用：

#include <iostream>
using namespace std;

void changeValue(int& ref) {
    ref = 20;
}

int main() {
    int num = 10;
    int& ref = num;

    cout << "Value of num: " << num << endl;
    cout << "Value of ref: " << ref << endl;

    changeValue(ref);

    cout << "Modified value of num: " << num << endl;

    return 0;
}

在上述代码中，声明了一个整数变量 num 和一个引用 ref，将引用 ref 绑定到变量 num 上。然后输出了 num 和 ref 的值。接着调用函数 changeValue 并传入引用 ref，该函数通过引用来修改了变量的值。最后输出修改后的 num 的值。

输出结果为：

Value of num: 10
Value of ref: 10
Modified value of num: 20

总结

关于数组、字符串和指针，下面是一些总结：

数组：

• 数组是一种存储相同类型数据元素的集合。
• 数组元素在内存中是连续存储的，可以通过下标访问和修改数组元素。
• 数组长度（即元素个数）在声明时需要确定，并且不能更改。
• 数组可以用于存储基本数据类型、对象或其他数组。

字符串：

• 字符串是由字符组成的字符序列。
• C++ 中的字符串可以使用字符数组或标准库中的 string 类型表示。
• 字符串以 null 结尾，即以空字符 '\0' 结束，以便于判断字符串的结束位置。
• 可以使用字符串常量或字符数组来初始化字符串变量。

指针：

• 指针是一个变量，存储另一个变量的内存地址。
• 指针可以通过 * 运算符解引用，获取指针指向的变量的值。
• 可以使用 & 运算符获取变量的地址并将其赋给指针。
• 指针可以进行算术运算，如指针自增、指针偏移等。

数组和指针的关系：

• 数组名可以看作是指向数组首元素的指针。
• 数组名可以进行自增、自减等指针操作。
• 可以通过指针来遍历数组，通过下标或指针偏移来访问数组元素。

字符串和指针的关系：

• 字符串可以由字符数组或指向字符的指针表示。
• 字符串常量是一个字符数组，可以通过指针来遍历和访问字符串中的字符。
• 可以使用指针对字符串进行操作，如拷贝、连接、比较等。

要点：

• 数组和字符串在操作时需要注意边界检查，以避免访问越界导致的问题。
• 字符串操作时要确保末尾有正确的空字符 '\0'。
• 指针操作时要注意空指针和野指针的处理，避免出现未定义行为。