C++ Initializing a Global Array

This is a version of your example that works in 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;
}

Use a vector:

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

then pass that to method A as an argument of type std::vector<int> const &.

Edit: Or make the vector a data member of your class and set it with:

size_t n;
std::cin >> n;
x.resize(n);

In C++ you can't directly size an array with a runtime value, only with constants.

You almost certainly want vector instead:

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

EDIT: flesh out answer.

I can't quite tell if you are trying to learn about arrays, or if you are trying to solve some practical problem. I'll assume the latter.

The only way for method A to have access to any variable is if it is in scope. Specifically, x must either be:

• a local, including a parameter (but you said no to parameter passing)
• a class member, or
• a global

Here is a solution in which x is a class member:

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)
  }
};

Be aware that arrays in C++ are much more basic (and dangerous) than in Java.

In Java, every access to an array is checked, to make sure the element number you use is within the array.

In C++, an array is just a pointer to an allocated area of memory, and you can use any array index you like (whether within the bounds of the array, or not). If your array index is outside the bounds of the array, you will be accessing (and modifying, if you are assigning to the array element!) whatever happens to be in memory at that point. This may cause an exception (if the memory address is outside the area accessible to your process), or can cause almost anything to happen (alter another variable in your program, alter something in the operating system, format your hard disk, whatever - it is called "undefined behaviour").

When you declare a local, static or global array in C++, the compiler needs to know at that point the size of the array, so it can allocate the memory (and free it for you when it goes out of scope). So the array size must be a constant.

However, an array is just a pointer. So, if you want an array whose size you don't know at compile time, you can make one on the heap, using "new". However, you then take on the responsibility of freeing that memory (with "delete") once you have finished with it.

I would agree with the posters above to use a vector if you can, as that gives you the kind of protection from accessing stuff outside the bounds of the array that you are used to.

But if you want the fastest possible code, use an allocated array:

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!
  }
}