sizeof dinamically alocated array....

[Mateo]

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this array....
Problem: sizeof operator does not work with dinamically alocated
arrays!?!?!

How can I determine size of dinamically alocated array.... ?
Please advice...
Thx!

[Victor Bazarov]

Mateo wrote:

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this
array.... Problem: sizeof operator does not work with dinamically
alocated arrays!?!?!

How can I determine size of dinamically alocated array.... ?

You cannot. You need to store the size at the time of allocation
and pass it into the same function. If you can't do that, do not
use a plain char array, use 'std::string'.

V
--
Please remove capital As from my address when replying by mail

[Phlip]

Mateo wrote:

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this
array....
Problem: sizeof operator does not work with dinamically alocated
arrays!?!?!

How can I determine size of dinamically alocated array.... ?

This is a Frequently Asked Question, but I don't know if it's in the FAQ.

The answer is you should use an std::vector<> unless you actually need a
primitive array, returned by new[].

If you have a legitimate reason not to use std::vector<>, then pass the size
with the array.

There's no portable way to get this information, because your program is
essentially throwing the information away after the new[] call. Don't.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[red floyd]

Phlip wrote:

The answer is you should use an std::vector<> unless you actually need a
primitive array, returned by new[].

Not to mention that for passing to library/OS routines that require a
naked T*, a std::vector<T> is trivially convertable to a T* by passing
&v[0].

[BobR]

Victor Bazarov wrote in message ...

Mateo wrote:

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this
array.... Problem: sizeof operator does not work with dinamically
alocated arrays!?!?!

How can I determine size of dinamically alocated array.... ?

You cannot. You need to store the size at the time of allocation
and pass it into the same function. If you can't do that, do not
use a plain char array, use 'std::string'.
V
--

Well, there's always the 'Three Stooges' method:

size_t SomeFunc( char /* const */ *MyCharArray ){
std::string ForSize( MyCharArray );
size_t ArrSize( ForSize.size() );
// Do something with MyCharArray that needs size.
// don't forget to add 1 if you need to include
// the '\0' at end of array.
return ArrSize;
// size_t ArrSize = sizeof( MyCharArray );
// return ArrSize; // returns 4 (the size of pointer)
}

int main(){
char MyCharArray[] = "abcd1234xy z";
std::cout<<"Som eFunc( MyCharArray ); "
<<SomeFunc( MyCharArray )<<std::endl;
return 0;
}
// output: SomeFunc( MyCharArray ); 11

--
Bob <G> R
POVrookie

[Victor Bazarov]

BobR wrote:

Victor Bazarov wrote in message ...

Mateo wrote:

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this
array.... Problem: sizeof operator does not work with dinamically
alocated arrays!?!?!

How can I determine size of dinamically alocated array.... ?

You cannot. You need to store the size at the time of allocation
and pass it into the same function. If you can't do that, do not
use a plain char array, use 'std::string'.
V
--

Well, there's always the 'Three Stooges' method:

size_t SomeFunc( char /* const */ *MyCharArray ){
std::string ForSize( MyCharArray );
size_t ArrSize( ForSize.size() );
// Do something with MyCharArray that needs size.
// don't forget to add 1 if you need to include
// the '\0' at end of array.
return ArrSize;
// size_t ArrSize = sizeof( MyCharArray );
// return ArrSize; // returns 4 (the size of pointer)
}

int main(){
char MyCharArray[] = "abcd1234xy z";
std::cout<<"Som eFunc( MyCharArray ); "
<<SomeFunc( MyCharArray )<<std::endl;
return 0;
}
// output: SomeFunc( MyCharArray ); 11

I believe you've confused the size of the array with the length of
a C string stored in it. Show it again with this 'MyCharArray':

int main() {
char MyCharArray[] = "abc\0def\0ghi\ 0jkl\0\0\0";
...

V
--
Please remove capital As from my address when replying by mail

[BobR]

Victor Bazarov wrote in message ...

BobR wrote:

Victor Bazarov wrote in message ...

Mateo wrote: [snip] How can I determine size of dinamically alocated array.... ?

You cannot. You need to store the size at the time of allocation
and pass it into the same function. If you can't do that, do not
use a plain char array, use 'std::string'.
V
--

Well, there's always the 'Three Stooges' method:

size_t SomeFunc( char /* const */ *MyCharArray ){
std::string ForSize( MyCharArray );
size_t ArrSize( ForSize.size() );
// Do something with MyCharArray that needs size.
return ArrSize;
}

int main(){
char MyCharArray[] = "abcd1234xy z";
std::cout<<"Som eFunc( MyCharArray ); "
<<SomeFunc( MyCharArray )<<std::endl;
return 0;
}
// output: SomeFunc( MyCharArray ); 11

I believe you've confused the size of the array with the length of
a C string stored in it. Show it again with this 'MyCharArray':

int main() {
char MyCharArray[] = "abc\0def\0ghi\ 0jkl\0\0\0";
...
V
--

Well, there's always the 'Three Stooges + Mickey Mouse' method: <G>

size_t SomeFunc2( char *MyCharArray ){
std::string ForSize( MyCharArray ); // the Mickey
std::string Look(3, '\0'); // the Mouse
size_t index( ForSize.size() );
while( ForSize.find( Look ) == std::string::np os ){
ForSize.push_ba ck( MyCharArray[index] );
++index;
}
size_t ArrSize( ForSize.size() );
// Do something with MyCharArray.
return ArrSize;
}

int main(){
char MyCharArray[] = "abc\0def\0ghi\ 0jkl\0\0\0";
std::cout<<"Som eFunc2( MyCharArray ); "
<<SomeFunc2( MyCharArray )<<std::endl;

std::cout<<"siz eof(MyCharArray )/sizeof(*MyCharA rray) "
<<sizeof(MyChar Array)/sizeof(*MyCharA rray)<<std::end l;
return 0;
}
// -- output --
// SomeFunc2( MyCharArray ); 18
// sizeof(MyCharAr ray)/sizeof(*MyCharA rray) 19

Either:
a - You have no sense of humor.
or
b - I've been had, and I tip my hat to you.

--
Bob R
POVrookie

[AnonMail2005]

Vector is the way to go.

I have read in Meyers that &v[0] is not advisable unless v.size () > 0.

red floyd wrote:

Phlip wrote:

The answer is you should use an std::vector<> unless you actually need a
primitive array, returned by new[].

Not to mention that for passing to library/OS routines that require a
naked T*, a std::vector<T> is trivially convertable to a T* by passing
&v[0].

[Phlip]

AnonMail2005 wrote:

Vector is the way to go.

I have read in Meyers that &v[0] is not advisable unless v.size () > 0.

To the intermediates:

Bow before /C++ Coding Standards : 101 Rules, Guidelines, and Best
Practices/ (C++ in Depth Series) by Herb Sutter & Andrei Alexandrescu. It
covers such scratchy situations as interfacing to a C API that likes raw
pointers.

They advise the &v[0] trick, and I can't recall if they warn about the
size() == 0 situation.

Now I thought that all containers always have a valid .begin() and .end(),
and if they equal then the container is empty, so this might suggest that
&v[0] is always valid (whereas v[0] is not, because it dereferences an
unconstructed object).

So where am I wrong?

To the newbies:

The original poster appeared to be writing their own function that takes a
pointer. If so, they should avoid pointers (as should coders at all levels),
and should pass a reference to a vector:

typedef std::vector<int > ints_type;
void foo(ints_type & ints);

References have fewer features, so they are always better than pointers, and
vectors have more features than arrays, so they are always better than
arrays.

Always pick the technique with fewer features. Or more features. I'll try
again.

Always pick the technique with the safest features. Raw pointers have many
unsafe features, and vectors have many safe ones.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[Tomás]

Mateo posted:

I have char *array and it is dinamically alocated....
When I pass it to other function, I need to determine size of this
array.... Problem: sizeof operator does not work with dinamically
alocated arrays!?!?!

How can I determine size of dinamically alocated array.... ?
Please advice...
Thx!

#include <cstddef>
#include <iostream>
using std::cout;
using std::endl;
template<std::s ize_t i>
void PrintStringLeng th( char (&str)[i] )
{
cout << "This string is " << (i - 1) << " characters long.\n";
}

int main()
{
char (&str)[7] = * reinterpret_cas t< char (*)[7] > ( new char[7] );

std::strcpy(str , "monkey");
PrintStringLeng th(str);

}
-Tomás