C++数组做题笔记

【题目描述】

输入n个数,要求程序按输入时的逆序把这n个数打印出来，已知整数不超过100100个。也就是说，按输入相反顺序打印这n个数。

【输入】

输入一行共有n个数，每个数之间用空格隔开。

【输出】

如题要求：一行，共有n个数，每个数之间用一个空格隔开。

【输入样例】

1 7 3 4 5

【输出样例】

5 4 3 7 1

#include <bits/stdc++.h>
using namespace std;

int main()
{
	vector<int> nums;
	int n;
	
	while(cin>>n)
	{
		nums.push_back(n);
	}
	for(int i=nums.size()-1;i>=0;i--)
	{
		cout<<nums[i]<<" ";
	}
	return 0;
}

这是一个简单的例子，通过这个例子讲几点注意事项：

• 如果数组定义的过大，且定义在main()内部，会直接异常退出。这是因为main（）函数定义在栈上，内存很小。所以会异常退出。解决办法就是：

在 C++ 中，数组的大小受到栈空间（stack）的限制。栈的空间通常是有限的，尤其是在32位或64位系统中，栈的大小可能较小，因此，如果数组非常大（例如，几百万个元素），在 main 函数中定义大型数组时可能会导致栈溢出错误。

为了解决这个问题，C++ 中有几种常见的方式来定义非常大的数组或处理大数据。

1. 使用动态内存分配（new 或 malloc）

通过 new 或 malloc 可以在堆（heap）上动态分配内存，堆的大小通常远大于栈，因此可以存储较大的数组。

示例：使用 new 关键字

#include <iostream>
using namespace std;

int main() {
    // 假设我们需要一个大小为1000000的整数数组
    int *arr = new int[1000000];  // 在堆上分配内存

    // 使用数组
    for (int i = 0; i < 1000000; ++i) {
        arr[i] = i;
    }

    // 打印数组的前几个元素
    for (int i = 0; i < 10; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // 使用完毕后，记得释放内存
    delete[] arr;

    return 0;
}

说明：

• new int[1000000] 在堆上动态分配一个大小为 1000000 的整数数组。
• delete[] arr; 用来释放通过 new 分配的内存，避免内存泄漏。

2. 使用 std::vector 动态数组

std::vector 是一个 C++ 标准库容器，它能够自动管理内存并动态调整数组的大小。对于大数组，使用 std::vector 是一个更为安全且简便的选择。

示例：使用 std::vector

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 使用vector来存储大数组
    vector<int> arr(1000000);  // 创建一个大小为1000000的vector

    // 使用数组
    for (int i = 0; i < 1000000; ++i) {
        arr[i] = i;
    }

    // 打印数组的前几个元素
    for (int i = 0; i < 10; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // vector会在离开作用域时自动释放内存

    return 0;
}

说明：

• std::vector<int> arr(1000000); 创建一个包含 1000000 个元素的 vector。
• std::vector 会自动管理内存，不需要手动释放内存，离开作用域时会自动释放。

3. 在函数外定义全局数组（或静态数组）

如果你需要一个非常大的数组，而且希望它在整个程序的生命周期内有效，可以考虑将数组定义为全局变量或静态变量。

示例：全局数组

#include <iostream>
using namespace std;

// 定义一个全局数组
const int MAX_SIZE = 1000000;
int arr[MAX_SIZE];

int main() {
    // 使用全局数组
    for (int i = 0; i < MAX_SIZE; ++i) {
        arr[i] = i;
    }

    // 打印数组的前几个元素
    for (int i = 0; i < 10; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

说明：

• 通过将数组定义在 main 函数外部，它成为了全局数组。在 main 函数内，依然可以使用该数组。
• 全局数组的内存通常分配在数据段（静态存储区），而不是栈上，因此不会受到栈大小限制。

4. 静态数组

如果数组大小在编译时已知，并且不希望动态分配内存，也可以将数组声明为静态数组。静态数组的内存也不是分配在栈上，而是在数据段中，因此可以用于非常大的数组。

示例：静态数组

#include <iostream>
using namespace std;

const int MAX_SIZE = 1000000;

void func() {
    static int arr[MAX_SIZE];  // 静态数组
    for (int i = 0; i < MAX_SIZE; ++i) {
        arr[i] = i;
    }

    // 打印数组的前几个元素
    for (int i = 0; i < 10; ++i) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main() {
    func();
    return 0;
}

说明：

• static int arr[MAX_SIZE]; 声明了一个静态数组，该数组的生命周期与程序一样长，但内存不在栈上，而是在数据段。
• 静态数组在整个程序运行期间是有效的。

总结：

• 栈内存有限：如果你在栈上分配太大的数组（尤其是数组非常大时），可能会导致栈溢出错误。一般来说，栈的大小较小（在 32 位系统上可能是 1MB，64 位系统上可能是 8MB 或更多）。
• 堆内存更大：通过 new 或 std::vector 动态分配内存可以避免栈溢出问题，堆内存较大，适合存储大数组。
• 全局/静态数组：如果需要在整个程序中访问数组，可以将数组定义为全局或静态数组，避免栈溢出。

        根据你的需求选择合适的方案。如果是非常大的数组且没有固定大小，推荐使用 std::vector 或 new 动态分配内存。

• 遇到while (cin >> num)这中情况：
  • EOF 结束输入：你需要通过 Ctrl+D (Linux/Mac) 或 Ctrl+Z (Windows) 来结束输入，这样程序才能读取完所有的数字并执行逆序输出。