Creating static array in c++ at run time

Is there a开发者_StackOverflowny way of creating a static array in c++ at run time. What i want is really simple like just want to get input number from user and create a static array of size of input number at run time. No new operator is required no pointer are required just static array?

No. static variable is allocated before the program code is actually running (i.e.: before your main is called). What you need is a dynamic (aka created at run time) array. If you want to avoid new you can create it on stack (by passing parameter to a function that will create it and working on it within that function), but that's not the same as static. You can also use template containers that will do the allocation and resizing for you (like std::vector, mentioned in other answers)

edit

It seems to bother some people that I didn't mention the matter of initializing static objects. Although not directly relevant to the question - worth to know that static member variables or static variables within a scope can be initialized at run time, but the space for them is reserved prior to the main, so the size of the variable cannot be changed.

If you mean

unsigned size;
std::cin >> size;
int arr[size];

Then: No. C99 has a feature called Variable-Length-Arrays, but the C++03 (and '0x) standard have no notion of this kind of feature.

Use alloca to allocate space on the stack, just like a static array or like a C99 variable length array.

#include <iostream>
#include <alloca.h>
int main() {
        unsigned sz;
        std :: cin >> sz;
        int * p = static_cast<int*>(alloca(sz * sizeof(int)));
        // do stuff with p, do not attempt to free() it
}

I've only ever used it with C, but it works well. Read about it first though. It probably isn't very portable.

No.

By definition, you need to dynamically allocate anything whose size is not known until runtime. That's why new and friends exist.

What does it mean to you that an array is static? What advantages do you think it gives you?

Actually, any static variable (including arrays) has its storage reserved at the beginning of the program. For this reason, its size has to be known before the program starts running, so it can't depend on user input in any way.

There are a number of ways to make dynamic non-static arrays, however, so let us know what you're trying to do.

It sounds like what you want is an array whose size is run-time defined but whose life time is defined by static storage duration (ie the length of the program).

You can not use the basic array built into the language. The size of these objects are defined at compile time and can not be modified at run-time. But there are a couple of alternatives.

The basic std::vector is probably what you want:

std::vector<int>    data;

int main()
{
    int size;
    std::cout << "Input the size of the array\n";
    std::cin >> size;

    // This line sets the size of the container
    // vector is basically a C++ wrapper around a dynamically sized array
    data.resize(size);

    // Now we can safely read values into the array (like) container.
    for(int loop =0;loop < size;++loop)
    {
        std::cout << "Input Value " << loop << "\n";
        std::cin >> data[loop];
    }
}