C++ C++；初始化全局数组

大家好。我是一个有经验的java程序员，我只是学习C++。 现在我有一个初学者的问题。我有一个int类型的数组变量x

用户将在方法B中输入x的大小。我想在方法A中使用x

void method A()
{
 using int x [] blah blah blah
}

void method B()
{
int n;
cin >>n;
int x [n]; // How can I use this int x in method A without getting error: storage size x is unknown.
// Or the error 'x' was not declared in this scope.
}

编辑：参数传递不是我想要的解决方案

双重编辑：我确实知道向量选项，但是我的程序很准时。我正在创建一个算法，其中每毫秒都有计数

顺便说一句，我找到了一种方法

int x [] = {}

method B();
method A () { blah blah use x}
method B () {/*int*/ x [n]}

使用向量：

std::vector<int> x(n);

---

<>在C++中，不能用运行时值直接对数组进行大小调整，只有常数。 几乎可以肯定，您需要的是vector：

---

std:：向量x（n）
编辑：充实答案

我不太清楚您是在学习数组，还是在解决一些实际问题。我假设是后者

方法A访问任何变量的唯一方法是它是否在范围内。具体而言，
x
必须是：


一个局部变量，包括一个参数（但您拒绝传递参数）
班级成员，或
全球性的

下面是一个解决方案，
x
是类成员：

class C {
public:
  std::vector<int> x;
  void A() {
    std::cout << x[2] << "\n"; // using x[], for example.
  }
  void B() {
    int n;
    cin >> n;
    x = std::vector<int>(n); // or, as others have pointed out, x.resize(n)
  }
};

C类{
公众：
std：：向量x；
作废{
标准：：cout n；
x=std:：vector（n）；//或者，正如其他人指出的，x.resize（n）
}
};
如果您实际上想要一个数组而不是向量，并且希望在运行时动态调整该数组的大小，则需要在堆上创建它（将其存储在指针中），并在完成后释放它

您需要理解C++中没有垃圾收集-任何你在<析构函数】中使用代码< >删除< /代码>的代码中的“<代码>新< /Calp>（在堆上创建）”。< /P>
class foo
{
    private:
    int *array;

    public:
    foo() { array = NULL; };
    ~foo()
    {
        if (array != NULL)
            delete [] array;
    }

    void createArray()
    {
        array = new int[5];
    }

};

更多信息：
< P>这是C++中的示例的一个版本。

#include <iostream>

int *my_array;

void methodA(a,b){
     my_array[a] = b;
}

int methodB(){
     int n;
     std::cin >> n;
     my_array = new int[n];
}

int main(){
     int x;
     x = methodB();
     methodA(x-1, 20);
     delete [] my_array;
     return 0;
}

#包括
int*my_数组；
无效方法a（a，b）{
my_数组[a]=b；
}
int methodB（）{
int n；
标准：cin>>n；
my_数组=新整数[n]；
}
int main（）{
int x；
x=方法b（）；
方法a（x-1,20）；
删除[]我的_数组；
返回0；
}
<>代码>注意PrimeC++中的数组比java中的更基本（更危险）。
在Java中，对数组的每次访问都会进行检查，以确保使用的元素号在数组中

<>在C++中，数组只是指向内存分配区域的指针，可以使用任何数组索引（无论数组的边界是否正确）。如果您的数组索引在数组的边界之外，那么您将访问（并修改，如果您分配给数组元素！）此时内存中发生的任何内容。这可能会导致异常（如果内存地址在进程可访问的区域之外），或者可能导致几乎任何情况发生（更改程序中的另一个变量、更改操作系统中的某些内容、格式化硬盘，等等，这称为“未定义行为”）

当你在C++中声明一个本地的、静态的或全局的数组时，编译器需要知道数组的大小，这样它就可以分配内存（当它超出范围时，它就可以释放它）。因此，数组大小必须是常量
然而，数组只是一个指针。因此，如果您想要一个在编译时不知道大小的数组，可以在堆上使用“new”创建一个。然而，一旦你完成了它，你就承担起释放内存的责任（用“删除”）

我同意上面的海报，如果可以的话，可以使用向量，因为这样可以防止访问数组边界之外的内容

但如果您想要最快的代码，请使用分配的数组：

class C {
 int [] x;

 void method A(int size)
 {
   x = new int[size];   // Allocate the array
   for(int i = 0; i < size; i++)
      x[i] = i;         // Initialise the elements (otherwise they contain random data)
   B();
   delete [] x;         // Don't forget to delete it when you have finished
                        // Note strange syntax - deleting an array needs the []
 }

 void method B()
 {
   int n;
   cin >> n;
   cout << x[n];
   // Be warned, if the user inputs a number < 0 or >= size, 
   // you will get undefined behaviour!
  }
}

C类{
int[]x；
无效方法A（整数大小）
{
x=newint[size]；//分配数组
对于（int i=0；i>n；
cout=大小，
//您将获得未定义的行为！
}
}
不要直接回答你的问题，但一定要买一本好书。下面是一个列表：如果我正确读取了您的伪代码，那么您已经在
方法B
中创建了一个数组作为局部变量。如果是这种情况，您应该意识到本地
x
隐藏了全局
x
的定义。也就是说，您在
B
中写入
x
的数据不会影响全局
x
，也不会在
A
中可见。所有的向下投票是怎么回事？我在第二版发布之前发布了我的答案。还有，@Jimmy Huch:如果每一纳秒都计数，那么使用一个数组。如果每天未花费调试计数，请使用
std:：vector
或
boost:：scoped_array
。抱歉，我的代码中有错误。在方法B（）中，它应该是{x[n]}而不是int x[n]Jimmy，您的“方法”实际上不起作用。这是两个完全不同的
x
变量。您在
B
中声明的内容对
A
可以做什么或看到什么没有影响。无论如何，你的原始方法B不是有效的C++（不管你在方法A中做了什么）。C++中的Charles Ray没有发现任何特殊的原因，当代码<矢量>代码>时，指针会使问题复杂化。问题是要数组，而不是向量。这是我在上一次评论中唯一考虑的问题。根据OP的说法，时间是必不可少的，所以向量肯定不会有用。@Charles Ray动态分配和指针的性能与向量几乎相同，更容易导致内存管理混乱。无法使用运行时确定大小的普通C数组，这是OP要求的？
class C {
 int [] x;

 void method A(int size)
 {
   x = new int[size];   // Allocate the array
   for(int i = 0; i < size; i++)
      x[i] = i;         // Initialise the elements (otherwise they contain random data)
   B();
   delete [] x;         // Don't forget to delete it when you have finished
                        // Note strange syntax - deleting an array needs the []
 }

 void method B()
 {
   int n;
   cin >> n;
   cout << x[n];
   // Be warned, if the user inputs a number < 0 or >= size, 
   // you will get undefined behaviour!
  }
}