Defining an Array's Length inside a Function possible?

Basically the topic :/
Is it possible to set an array in a function?
I'm trying to get it so I can have an array in a class without a set size, and then when I'm ready to set it's size I can do so with a function.

I don't really have a script, just messing with the idea for now.. Any help appriciated :)

Using dynamic allocation (ie new and delete) yes. Using non dynamic allocation: compiler dependant

Code:

---

void somefunc(int size)
{
  char *buffer = new char[size]; // allocate enough room for size characters
  // do some stuff with buffer
  delete[] buffer; // free the allocate memory
}

---

Then you just call it:

Code:

---

somefunc(10);
somefunc(20);

---

etc

Rather than working with error prone dynamic memory you should consider using the standard vector class. Not only can you set the size dynamically, but the vector grows dynamically as well without any extra work on your part. And vectors are safer. They save you from the hassle of memory management and special exception frameworks.

But if you don't need all the functionality of the vector class why use it???? Not all memory code needs to use the STL.

Use malloc.

And exceptions can be caused by more than just malloc so you do not get away from exceptions by not using it.

>>But if you don't need all the functionality of the vector class why use it????
A better question in my opinion would be why not use it? It would be much better to solve the problem simply and safely first. Then if there are performance problems you can drop to a lower level.

>>Use malloc.
new would be preferable in C++.

>>so you do not get away from exceptions by not using it
True, but you do escape awkward situations where an exception is thrown and memory must be released. The destructor of a container class will handle that automatically whereas if you manage your own memory you must jump through a few hoops to clean up properly. The water begins to get murky when you needlessly work at such a low level.

Quote:

---

Originally Posted by Princeton

True, but you do escape awkward situations where an exception is thrown and memory must be released. The destructor of a container class will handle that automatically whereas if you manage your own memory you must jump through a few hoops to clean up properly. The water begins to get murky when you needlessly work at such a low level.

---

Very true, encapsulation greatly helps exception handling.

More specifically, it reduces the need for rethrowing exceptions:

Code:

---

void f()
{
  int* p = new int[...];
  try
  {
        doSomething(p);
  }
  catch(...)
  {
        delete[] p;
        throw;  //Rethrow exception after cleaning up
  }
  delete[] p;
}

---

This could have been written:

Code:

---

void f()
{
  vector<int> p(...);
  doSomething(p);
}

---

Granted the vector class provides much more functionality and is pure C++ unlike malloc...which whoever docked me points for saying use malloc....you are a moron...I know there is no malloc in C++.

However noone said you have to be pure C++ or pure C in any one program. My point is that this thread has been hijacked because the original question was about something very simple and yet we have turned it into something very complex.

>>I know there is no malloc in C++.
malloc is valid C++, there is just little use for it because it does not handle constructors properly and new is a cleaner alternative.

>>which whoever docked me points for saying use malloc....you are a moron...
I merely stated that new is preferred. I appologize if that insulted you in any way.

>>My point is that this thread has been hijacked
I thought your point was that using standard containers is overkill and manual memory management should be preferred. However, I do not feel that the thread has lost it's topicality because the discussion is pertinent to the original question.

Quote:

---

you are a moron...I know there is no malloc in C++.

---

Who's the what now? Of course there's malloc in C++!

Quzah.

Back to the original question...Typically a class with templates is used, but I believe that you should be able to do

Code:

---

template<int N__>
void f()
{
        int a[N__];             
}

---

Then, you would call f like f<50>() where 50 is the size of the array.

Quote:

---

you are a moron...I know there is no malloc in C++.

---

Quote:

---

Who's the what now? Of course there's malloc in C++!

Quzah.

---

You know what we mean Quzah. New and delete are much better for dynamic memory allocation.

:)

I dunno why people get so bent out of shape about pure C or pure C++.

Quote:

---

Originally Posted by okinrus

Back to the original question...Typically a class with templates is used, but I believe that you should be able to do

Code:

---

template<int N__>
void f()
{
        int a[N__];             
}

---

Then, you would call f like f<50>() where 50 is the size of the array.

---

I tried to test your code quickly and see what I got... tried the following and got unexpected results:

Code:

---

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

template <int N> void f()
{
    int array[N];
    for( int x = 0; x < N; ++x )
        array[x] = rand();
    for( int y = 0; y < N; ++y )
        cout << array[y] << endl;
}

int main()
{
    f<2>();
    cout << "Hello World" << endl;
    f<4>();
    return 0;
}

---

Output was:

Code:

---

41
18467
6334
26500
Hello World
19169
15724
11478
29358

---

Maybe it's my implementation (MSVC++ 6.0) but it seem the f<4>() call ends up setting the size for both calls. If I switch the order around so that the f<4>() call comes first and the f<2>() call comes last, I get:

Code:

---

41
18467
Hello World
6334
26500

---

That's odd. I have msvc++ 7.1 and the output I get for code such as this is
a's size = 2
a's size = 4

Code:

---

template<int N__>
void f()
{
    int a[N__];

    std::cout << "a's size = " << sizeof a/sizeof(int) << std::endl;
}

int main()
{
    f<2>();
    f<4>();

    return 0;
}

---

I'm pretty sure that msvc++ 6.0 should be able to handle code like this

Code:

---

template<int N__>
class Static_array {
public:
      Static_array() { std::cout << "N__ = " << N__ << std::endl; }
private:
      int a[N__];
};

---

A technique similar to this is described in C++ analysis and design by Booch, somewhat before the addition of namespaces, I think.

I don't even know what a vectore class is :P
If its a windows thing, I don't do it :P