Create a variable size but non-growable array

[yinglcs]

Hi,

In STL, can I create a variable size but non-growable array?

In Java, I can do this:

int[] void f (int size) {
int[] array = new int[size];
// do something with array
return array;
}

I guess I can use vector<> for that, but I don't need the array to be
growable, I just don't know the size upfront. So I am looking for a
more efficient data structure.

Thank you.

[Victor Bazarov]

yi*****@gmail.com wrote:

In STL, can I create a variable size but non-growable array?
Not in STL. In C++.
In Java, I can do this:

int[] void f (int size) {
int[] array = new int[size];
// do something with array
return array;
}
In C++ you do

int* void f(int size) {
return new int[size];
}
I guess I can use vector<> for that,
But std::vector has exactly the opposite purpose: it's _growing_ as
needed.
but I don't need the array to be
growable,
Dynamic arrays are never "growable".
I just don't know the size upfront. So I am looking for a
more efficient data structure.

To do what?

V

[Neelesh Bodas]

yi*****@gmail.com wrote:

Hi,

In STL, can I create a variable size but non-growable array?
You can do that even with C++. Use dynamic memory allocation
In Java, I can do this:

int[] void f (int size) {
<OT> Aside, A function cannot have _two_ return types - not even in
Java </OT>
int[] array = new int[size];
// do something with array
return array;
}
int C++ you have
int* f(int size)
{
int * array = new int[size];
return array;
}

Note : you need to take care of freeing array exactly once.

I guess I can use vector<> for that, but I don't need the array to be
growable, I just don't know the size upfront. So I am looking for a

Make sure wherether
1) You donot _need_ the array to be growable
2) You donot _want to allow_ the array to be growable.

unless it is second case, std::vector is preferable

[yinglcs]

Okay, thanks for the help.

Suppose I do this in c++:
int* f(int size)
{
int * array = new int[size];
return array;

}

Is there a safe idiom to prevent memory leak? Should i use auto_ptr in
C++?
Or should I use other smart pointer template in other libraries?

Thank you.

[xzgyb]

auto_ptr not suitable for the pointer of array
try scoped_array of boost library

[Neelesh Bodas]

yi*****@gmail.com wrote:

Suppose I do this in c++:
int* f(int size)
{
int * array = new int[size];
return array;

}

Is there a safe idiom to prevent memory leak? Should i use auto_ptr in
C++?

You can write a RAII wrapper similar to this:

template<class T> class Array {
T* data;
public:
Array(int sz) : data(new T[sz]) { }
~Array()
{
delete[] data;
}
// define CC, operator=, operator[] and other operators that are
necessary
// decide whether you want a shallow or a deep copy for CC and
operator=
};
Array<int> foo(int size)
{
return Array<int>(size);
}

int main()
{
Array<int> p = foo(5);
} // ~Array<int> for p automatically called.

[yinglcs]

Thanks.

The reason I ask this question is from what I read in c++ primer 3rd
edition, it said non-const variable size array is illegal.

Page 114 C++ Primer:

The following are examples of both legal and illegal array definitions:

// both buf_size and max_files are const
const int buf_size = 512;
int staff_size = 27;

// ok: const variable
char input_buffer[ buf_size];

// error: non-const variable
double salaries[ staff_size];

[Neelesh Bodas]

[e-mail] wrote:

Thanks.

The reason I ask this question is from what I read in c++ primer 3rd
edition, it said non-const variable size array is illegal.
What this means is that when you declare an array, the size must be
known at compile time. What we are doing in your example is allocating
a chunk of memory (which is guaranteed to be contiguous) and accessing
it through operator[], since a[i] is a syntactic sugar for *(a+i)

Note that when we say
int * arr = new int[10];

arr is simply an integer pointer - it is _not_ an array name. We can
make arr point to somewhere else :
int k;
arr=&k; // works

such assignment would not have been possible had arr been an array
name.
The following are examples of both legal and illegal array definitions:

// both buf_size and max_files are const
const int buf_size = 512;
int staff_size = 27;

// ok: const variable
char input_buffer[ buf_size];

// error: non-const variable
double salaries[ staff_size];

since staff_size is not a compile time constant, this is illegal.

[ogerchikov]

Thanks for your clear explanation.

[yinglcs]

Thanks for your response.

[Martin Vejnar]

Neelesh Bodas wrote:

You can write a RAII wrapper similar to this:

template<class T> class Array {
T* data;
public:
Array(int sz) : data(new T[sz]) { }
~Array()
{
delete[] data;
}
// define CC, operator=, operator[] and other operators that are
necessary
// decide whether you want a shallow or a deep copy for CC and
operator=
};

Unless you want a shallow copy, isn't this exactly what std::vector does?

Martin

[Neelesh Bodas]

Martin Vejnar wrote:

Neelesh Bodas wrote:

You can write a RAII wrapper similar to this:

Unless you want a shallow copy, isn't this exactly what std::vector does?

Yes. std::vector is preferrable unless OP wants to _explicitly
disallow_ all other features that std::vector provides (one of them
being push_back)

[yinglcs]

Thanks. But why I can't use the auto_ptr in c++?
If not, can I use one of the smart pointer from Boost library?

[Bo Persson]

<yi*****@gmail.com> skrev i meddelandet
news:11**********************@o13g2000cwo.googlegr oups.com...

Okay, thanks for the help.

Suppose I do this in c++:
int* f(int size)
{
int * array = new int[size];
return array;

}

Is there a safe idiom to prevent memory leak? Should i use auto_ptr
in
C++?

No, you should use std::vector. :-)

Once you set the vector to the proper size, it stays that size. And it
will manage its own memory.
Bo Persson

[Neelesh Bodas]

yi*****@gmail.com wrote:

Thanks. But why I can't use the auto_ptr in c++?
Because auto_ptr wraps a "pointer to an object", not a "pointer to an
array"
If not, can I use one of the smart pointer from Boost library?

boost::scoped_array

[Default User]

Neelesh Bodas wrote:

yi*****@gmail.com wrote:

Hi,

In STL, can I create a variable size but non-growable array?

You can do that even with C++. Use dynamic memory allocation

Yes and no. You have a pointer to dynamically allocated block of memory
that in almost all cases acts like an array of that type and size. It
will almost certainly satisfy the OP's needs.

It's not a true variable-size array, which is something that was added
to C in the C99 standard. C has more need of it because they don't have
standard containers like vector.

Brian

[roberts.noah]

yi*****@gmail.com wrote:

Hi,

In STL, can I create a variable size but non-growable array?

In Java, I can do this:

int[] void f (int size) {
int[] array = new int[size];
// do something with array
return array;
}

I guess I can use vector<> for that, but I don't need the array to be
growable, I just don't know the size upfront. So I am looking for a
more efficient data structure.

You could always do something like this:

template<typename T>
class array
{
T * arr;
int sz;
public:
array(int x) { arr = new T[x]; sz = x; }
~array() { delete [] arr; }
T & operator[](int i) { return arr[i]; }
int size() { return sz; }
};

That is of course a very simplistic version but it meets the stated
requirements and is relatively safe to use. You would want to add copy
and assignment ops to meet the rule of three but on the other hand this
class can be used as an array of sorts in a memcpy:

memcpy(&a1[0], &a2[0], a2.size() * sizeof(a2[0]));

But this is just as dangerous as doing so with your basic dyn array.
The benefit of using operators would be that you can do some checks and
throw up if the op would result in a buffer overrun. Also, passing by
value would be very ill advised without those operators; would result
in a crash.

[Clark S. Cox III]

On 2006-01-11 16:23:46 -0500, ro**********@gmail.com said:

yi*****@gmail.com wrote:

Hi,

In STL, can I create a variable size but non-growable array?

In Java, I can do this:

int[] void f (int size) {
int[] array = new int[size];
// do something with array
return array;
}

I guess I can use vector<> for that, but I don't need the array to be
growable, I just don't know the size upfront. So I am looking for a
more efficient data structure.

You could always do something like this:

template<typename T>
class array
{
T * arr;
int sz;
public:
array(int x) { arr = new T[x]; sz = x; }
~array() { delete [] arr; }
T & operator[](int i) { return arr[i]; }
int size() { return sz; }
};

Don't forget a copy constructor and assignment operator (rule of 3)
--
Clark S. Cox, III
cl*******@gmail.com