C++ Initializing a Global Array

Hey everyone. I am an experienced java programmer and am just learning C++.

Now I have a bit of a beginner's problem. I have an array variable x of type int.

The user will input the size of x in method B. I want to use x in method A.

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

EDIT: Parameter passing isn't a solution I am looking for.

DOUBLE EDIT: I do know about the vector option, but my program is cramming on ti开发者_开发百科me. I am creating an algorithm where every millisecond counts.

BTW I found out a way of doing it.

int x [] = {}

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

If you actually want an array and not a vector, and you want that array dynamically sized at runtime, you would need to create it on the heap (storing it in a pointer), and free it when you're done.

Coming from Java you need to understand that there's no garbage collection in C++ - anything you new (create on the heap) in an object you will want to clean up in the destructor with delete.

class foo
{
    private:
    int *array;

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

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

};

More info at: http://www.cplusplus.com/doc/tutorial/dynamic/

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