HELP! dynamic array of char* 
Author Message
 HELP! dynamic array of char*

I'm trying to dynamically declare an array of strings, and no matter
what I do, I get errors.

I've done this before with other data types -- I know that if you want
to declare an array of integers with a size to be determined at run
time, you just declare:

        int     *myArray;

and then in the program,

        myArray = (int*)malloc(NumberOfElements * sizeof(int));

and subsequently, myArray[5] will reference as expected.

But what about an array of strings?

I declare

        char    *strings;

and then do

        strings = (char*)malloc(NumberOfStrings * sizeof(char*));

which gives me enough space for NumberOfStrings worth of pointers to
characters, right? Okay.

But then I need to put something in those spaces, so I do

        strings[index] = (char*)malloc(LengthOfString * sizeof(char));

and I get an "illegal pointer arithmetic" error.

I don't get it. malloc is returning to me a pointer to the beginning
of LengthOfString bytes of storage. A string variable is a pointer to
an array of characters. It seems to me that I'm assigning one member
of my array of string variables to point to an (as yet uninitialized)
string. Obviously the compiler does not see it this way. :-) Can
anyone point out what I'm missing?

Thanks!

--


GEnie: K.FICARA / Compuserve: 71311,1461 / AOL: KENFICARA / Prodigy:(NOT!)



Fri, 15 Sep 1995 09:41:07 GMT  
 HELP! dynamic array of char*

Quote:

>But what about an array of strings?

>I declare

>    char    *strings;

But this is an array of characters.  If you must do something like
this, then you need to declare "char **strings" or "char *strings[]"
or whatever, depending on what you intend to do with the array
later.

--





Fri, 15 Sep 1995 11:35:40 GMT  
 HELP! dynamic array of char*
: But what about an array of strings?

: I declare

:       char    *strings;
 ^^^ Here you defined 'strings' as a pointer to a character and not as a
 array of pointers. You can define strings as 'char **strings;' Then you
 can do

 strings = (char **) malloc (NumberOfString * sizeof (char *));
 *(strings+index) = (char *)malloc(LengthOfString * sizeof(char));

 surendar



Fri, 15 Sep 1995 11:02:58 GMT  
 HELP! dynamic array of char*

Quote:

>I'm trying to dynamically declare an array of strings, and no matter
>what I do, I get errors.

>I've done this before with other data types -- I know that if you want
>to declare an array of integers with a size to be determined at run
>time, you just declare:

>    int     *myArray;

>and then in the program,

>    myArray = (int*)malloc(NumberOfElements * sizeof(int));

>and subsequently, myArray[5] will reference as expected.

You must be using the small model of your compiler (if you're on PC's) or
else the machine you use has 32 bit ints and 32 bit pointers. In this case,
the compiler will generate an warning, but not an error.

Quote:

>But what about an array of strings?

>I declare

>    char    *strings;

>and then do

>    strings = (char*)malloc(NumberOfStrings * sizeof(char*));

>    strings[index] = (char*)malloc(LengthOfString * sizeof(char));

>and I get an "illegal pointer arithmetic" error.

Yes, this is what is supposed to happen. The declaration char *strings is a
pointer to a single character. Because the size of a character is less than
the size of a pointer, you can't convert a character pointer to fit into the
space of a single character. The error that my Borland compiler gives me is
perhaps a little better: non portable pointer conversion. With warnings
turned on, my compiler also flags the integer expression you gave first, but
doesn't {*filter*}on it because a pointer will fit into an integer's space.

You *can* do the indexing on strings, just try strings [2] =  10 and it will
work just fine.

What you need is a pointer to a pointer. With that, you won't be pointing at
characters, but at an array of pointers to strings.

Here's your example modified.

char **strings;
   strings = (char **) malloc (NumberOfStrings * sizeof (char *));

   strings [index] = (char *) malloc (Length of String);

Good luck,

------------------////////////////////\\\\\\\\\\\\\\\\\\\\------------------
| Patrick Draper-ZBT       Disclaimer:  I can't control my fingers,        |

| University of Michigan Computer Club                                     |
NO CARRIER                     We are a nation of laws, not people         |
------------------\\\\\\\\\\\\\\\\\\\\////////////////////------------------



Fri, 15 Sep 1995 11:54:35 GMT  
 HELP! dynamic array of char*

Quote:

>I'm trying to dynamically declare an array of strings, and no matter
>what I do, I get errors.
>But what about an array of strings?
>I declare
>    char    *strings;
>and then do
>    strings = (char*)malloc(NumberOfStrings * sizeof(char*));
>which gives me enough space for NumberOfStrings worth of pointers to
>characters, right? Okay.

  No, it gives you a pointer to NumberOfStrings times sizeof(char *)
characters.  Try:

  char **strings;
  strings = (char **) calloc(NumberOfStrings, sizeof(char *));

brian



Fri, 15 Sep 1995 11:48:15 GMT  
 HELP! dynamic array of char*
Quote:


>>I'm trying to dynamically declare an array of strings, and no matter
>>what I do, I get errors.

>>I've done this before with other data types -- I know that if you want
>>to declare an array of integers with a size to be determined at run
>>time, you just declare:

>>        int     *myArray;

>>and then in the program,

>>        myArray = (int*)malloc(NumberOfElements * sizeof(int));

>>and subsequently, myArray[5] will reference as expected.

>You must be using the small model of your compiler (if you're on PC's) or
>else the machine you use has 32 bit ints and 32 bit pointers. In this case,
>the compiler will generate an warning, but not an error.

I don't understand this...

  The way I read it, myArray is a pointer to int, and the malloc is cast
to a pointer to int.  Likewise, malloc takes a single argument of type
size_t, which it gets (i.e. NumberOfElements * sizeof(int)).  So there
is no int/pointer confusion here...

  The other place for int/pointer confusion is in the subsequent
expression myArray[5], which is semantically identical to *(myArray+5),
which also has no pointer/int confusion.  myArray is a pointer to int,
and pointer arithmetic dictates that (myArray+5) should point to the 5th
integer after myArray.  integer+pointer (and pointer+integer) is a valid,
well-defined construct, which does what the original poster wants.
Dereferencing this is valid (Assuming that myArray+5 points to valid
memory, which it would if NumberOfElements is at least 6).

I don't see where any of this relies on a flat address space, or on
sizeof(int) == sizeof(int *).  If I'm wrong, please correct me,
explaining it clearly.

- Show quoted text -

Quote:

>>But what about an array of strings?

>>I declare

>>        char    *strings;

>>and then do

>>        strings = (char*)malloc(NumberOfStrings * sizeof(char*));

>>        strings[index] = (char*)malloc(LengthOfString * sizeof(char));

>>and I get an "illegal pointer arithmetic" error.

>Yes, this is what is supposed to happen. The declaration char *strings is a
>pointer to a single character. Because the size of a character is less than
>the size of a pointer, you can't convert a character pointer to fit into the
>space of a single character. The error that my Borland compiler gives me is
>perhaps a little better: non portable pointer conversion. With warnings
>turned on, my compiler also flags the integer expression you gave first, but
>doesn't {*filter*}on it because a pointer will fit into an integer's space.

But why does it flag the integer expression in the first case?  The only
reason I can think of for why it would do that is if a declaration for
malloc was not in scope (making it default as returning int, not void *
(or char *)).  If it defaults to int, then, sure, you;ll have a problem.
With a declaration in scope, you should have no problem.

Quote:

>You *can* do the indexing on strings, just try strings [2] =  10 and it will
>work just fine.

>What you need is a pointer to a pointer. With that, you won't be pointing at
>characters, but at an array of pointers to strings.

>Here's your example modified.

>char **strings;
>   strings = (char **) malloc (NumberOfStrings * sizeof (char *));

>   strings [index] = (char *) malloc (Length of String);

>Good luck,

This should work just as well as the first expression (ie. with ints).

In the first case, he was trying to get a dynamically allocated array of
integers.  He used (effectively):

int *intarray = (int *) malloc(size * sizeof(int));

which is (IMHO) correct.  In the second case, he was trying to get a
dynamically allocated array of strings.  He used (effectively):

char *strarray = (char *) malloc (size * sizeof(char *));

which is (IMHO) incorrect, but I don't think any error would result
until he tried to use strarray[n] in a string (char *) context, since
strarray points to a character.  You suggested using

char **strarray = (char **) malloc (size * sizeof(char *));

which is (IMAYHO) correct.  However, if this malloc is correct, I don't
see how the first malloc is incorrect.  If the array indexing to this
one is correct (which, IMHO, it is), then the first (I believe) is also.
If I follow you correctly, you think that the first is wrong and the
second is correct.  Why?

Quote:

>------------------////////////////////\\\\\\\\\\\\\\\\\\\\------------------
>| Patrick Draper-ZBT       Disclaimer:  I can't control my fingers,        |

>| University of Michigan Computer Club                                     |
>NO CARRIER                     We are a nation of laws, not people         |
>------------------\\\\\\\\\\\\\\\\\\\\////////////////////------------------

--
-----

(insert-file ".disclaimer")
"I'm not an actor, but I play one on TV."


Fri, 15 Sep 1995 13:31:01 GMT  
 HELP! dynamic array of char*

Quote:

>>You must be using the small model of your compiler (if you're on PC's) or
>>else the machine you use has 32 bit ints and 32 bit pointers. In this case,
>>the compiler will generate an warning, but not an error.

>I don't understand this...

>  The way I read it, myArray is a pointer to int, and the malloc is cast
>to a pointer to int.  Likewise, malloc takes a single argument of type
>size_t, which it gets (i.e. NumberOfElements * sizeof(int)).  So there
>is no int/pointer confusion here...

In the expression with the integers, the poster was attempting to put
pointers into an array of integers. It just so happened that the size of a
pointer was exactly the size of an integer on his machine.

I tried this with both small model (16 bit pointers) and large model (32 bit
pointers) on a PC with 16 bit integers. When I compiled the integer example
under small model, the compiler complained with a warning, because of a type
conversion. The compiler then went ahead and converted the integer pointers
to integers, because they were both 16 bits.

Under the large mode, the compiler spit it out with an *error* because the
integers were still 16 bits, and the pointers wer 32 bits. No conversion was
possible. Under most UNIX machines, both integers and pointers are 32 bits,
so the compiler would normally be able to make the conversion and spit out a
warning if warnings were enabled.

Quote:
>I don't see where any of this relies on a flat address space, or on
>sizeof(int) == sizeof(int *).  If I'm wrong, please correct me,
>explaining it clearly.

It does, because if the sizes are different, the compiler cannot convert the
(int *) to an (int).

Quote:
>>Yes, this is what is supposed to happen. The declaration char *strings is a
>>pointer to a single character. Because the size of a character is less than
>>the size of a pointer, you can't convert a character pointer to fit into the
>>space of a single character. The error that my Borland compiler gives me is
>>perhaps a little better: non portable pointer conversion. With warnings
>>turned on, my compiler also flags the integer expression you gave first, but
>>doesn't {*filter*}on it because a pointer will fit into an integer's space.

>But why does it flag the integer expression in the first case?  The only

Because the compiler is doing a conversion of an integer pointer to an
integer. That's non-portable because an integer and a pointer might not be
the same size, or arithmetic might be defined differently on an integer or a
pointer.

Quote:

>char *strarray = (char *) malloc (size * sizeof(char *));

>which is (IMHO) incorrect, but I don't think any error would result
>until he tried to use strarray[n] in a string (char *) context, since
>strarray points to a character.  You suggested using

>char **strarray = (char **) malloc (size * sizeof(char *));

>which is (IMAYHO) correct.  However, if this malloc is correct, I don't
>see how the first malloc is incorrect.  If the array indexing to this
>one is correct (which, IMHO, it is), then the first (I believe) is also.
>If I follow you correctly, you think that the first is wrong and the
>second is correct.  Why?

Unless I declare storage space in the exact units that I need, I can't
guarentee that the code will be portable. For example, I will agree that I
can get char *strarray to work under any platform, but that doesn't make it
correct. Using a char to represent a char * is dangerous, because the
relationship between these units might change.

For example, to use the ridiculous, lets suppose that I use an array of
doubles instead of an array of characters:

double *strarray;   /* pointer to a double - MS-DOS doubles are 6 bytes */

   strarray = (double *) malloc (NStrings * sizeof (char *));

In this case, I've used an absurd unit to put on my array. I don't want an
array of doubles any more than I want an array of characters! What I want,
and need, is an array of pointers to characters!

Quote:
>-----

>(insert-file ".disclaimer")
>"I'm not an actor, but I play one on TV."

------------------////////////////////\\\\\\\\\\\\\\\\\\\\------------------
| Patrick Draper-ZBT       Disclaimer:  I can't control my fingers,        |

| University of Michigan Computer Club                                     |
NO CARRIER                     We are a nation of laws, not people         |
------------------\\\\\\\\\\\\\\\\\\\\////////////////////------------------


Fri, 15 Sep 1995 15:51:08 GMT  
 HELP! dynamic array of char*

Quote:

>In the expression with the integers, the poster was attempting to put
>pointers into an array of integers.

Not at all.  Here is the relevant part of the original post by Ken Ficara:

Quote:
>                                               I know that if you want
>to declare an array of integers with a size to be determined at run
>time, you just declare:

>    int     *myArray;

>and then in the program,

>    myArray = (int*)malloc(NumberOfElements * sizeof(int));

>and subsequently, myArray[5] will reference as expected.

This declares myArray as a pointer to int, and then allocates room for
NumberOfElements ints, storing a pointer to the first one into the pointer
called myArray.  There's nothing here to indicate any attempt to convert an
(int *) into an (int).  If you're getting warnings from any compiler, you must
have some strange expression of your own substituted for "myArray[5] will
reference as expected".  I read this as meaning that myArray[5] can be used
as an lvalue of type (int).  Can you show us your code that puts pointers into
the elements of myArray?

--
Morris M. Keesan                        The Boston Software Works, Inc.

(617)482-9898                           Boston, MA 02109



Sat, 16 Sep 1995 01:51:23 GMT  
 HELP! dynamic array of char*

Quote:


>>>You must be using the small model of your compiler (if you're on PC's) or
>>>else the machine you use has 32 bit ints and 32 bit pointers. In this case,
>>>the compiler will generate an warning, but not an error.

>>I don't understand this...

>>  The way I read it, myArray is a pointer to int, and the malloc is cast
>>to a pointer to int.  Likewise, malloc takes a single argument of type
>>size_t, which it gets (i.e. NumberOfElements * sizeof(int)).  So there
>>is no int/pointer confusion here...

>In the expression with the integers, the poster was attempting to put
>pointers into an array of integers. It just so happened that the size of a
>pointer was exactly the size of an integer on his machine.

You're right, this would be an error, but that's NOT what he was
doing...  I quote the original message (his code got deleted in this
thread):

---------Start---Quoted----Material-------
I'm trying to dynamically declare an array of strings, and no matter
what I do, I get errors.

I've done this before with other data types -- I know that if you want
to declare an array of integers with a size to be determined at run
time, you just declare:

        int     *myArray;

and then in the program,

        myArray = (int*)malloc(NumberOfElements * sizeof(int));

and subsequently, myArray[5] will reference as expected.

--------End---Quoted-----Material---------

In this code example, he is declaring an array of integers.  He doesn't
demonstrate putting anything into the array, but from his statements ("I
know that if you want to declare an array of integers..."), it seems
that he expects myArray[5] to be an int, not an (int *).

His second example, dealing with the array of strings, exhibits the
problem you say his first example does (except assuming that
sizeof(char) == sizeof(char *), which is less believable than
sizeof(int) == sizeof(int *)).

Quote:
>I tried this with both small model (16 bit pointers) and large model (32 bit
>pointers) on a PC with 16 bit integers. When I compiled the integer example
>under small model, the compiler complained with a warning, because of a type
>conversion. The compiler then went ahead and converted the integer pointers
>to integers, because they were both 16 bits.

>Under the large mode, the compiler spit it out with an *error* because the
>integers were still 16 bits, and the pointers wer 32 bits. No conversion was
>possible. Under most UNIX machines, both integers and pointers are 32 bits,
>so the compiler would normally be able to make the conversion and spit out a
>warning if warnings were enabled.

I'd like to see the code you tested.  Perhaps you misunderstood his
original example, but I sincerely doubt that your code accurately
reflects his example.

- Show quoted text -

Quote:
>>I don't see where any of this relies on a flat address space, or on
>>sizeof(int) == sizeof(int *).  If I'm wrong, please correct me,
>>explaining it clearly.

>It does, because if the sizes are different, the compiler cannot convert the
>(int *) to an (int).

>>>Yes, this is what is supposed to happen. The declaration char *strings is a
>>>pointer to a single character. Because the size of a character is less than
>>>the size of a pointer, you can't convert a character pointer to fit into the
>>>space of a single character. The error that my Borland compiler gives me is
>>>perhaps a little better: non portable pointer conversion. With warnings
>>>turned on, my compiler also flags the integer expression you gave first, but
>>>doesn't {*filter*}on it because a pointer will fit into an integer's space.

>>But why does it flag the integer expression in the first case?  The only

>Because the compiler is doing a conversion of an integer pointer to an
>integer. That's non-portable because an integer and a pointer might not be
>the same size, or arithmetic might be defined differently on an integer or a
>pointer.

But is isn't doing a conversion from (int *) to (int), not unless
malloc is returning an int.  Since malloc isn't supposed to be returning
an int, then either your compiler is broke, or malloc isn't declared
properly.

- Show quoted text -

Quote:

>>char *strarray = (char *) malloc (size * sizeof(char *));

>>which is (IMHO) incorrect, but I don't think any error would result
>>until he tried to use strarray[n] in a string (char *) context, since
>>strarray points to a character.  You suggested using

>>char **strarray = (char **) malloc (size * sizeof(char *));

>>which is (IMAYHO) correct.  However, if this malloc is correct, I don't
>>see how the first malloc is incorrect.  If the array indexing to this
>>one is correct (which, IMHO, it is), then the first (I believe) is also.
>>If I follow you correctly, you think that the first is wrong and the
>>second is correct.  Why?

>Unless I declare storage space in the exact units that I need, I can't
>guarentee that the code will be portable. For example, I will agree that I
>can get char *strarray to work under any platform, but that doesn't make it
>correct. Using a char to represent a char * is dangerous, because the
>relationship between these units might change.

OK, explain to me where I am using a char to represent a (char *) in my
example.  As I see it, strarray is a pointer to a pointer to a char, and
the malloc is allocating space for size pointers to char.  Each of those
pointers to char point to the first (0th) character in a string.  This
is correct usage.  I am not using a char to hold a char *.  

The first example, which was a paraphrase of Ken's original posting,
strarray WAS a pointer to a char.  This, as I said before, is wrong.

Quote:
>For example, to use the ridiculous, lets suppose that I use an array of
>doubles instead of an array of characters:

>double *strarray;   /* pointer to a double - MS-DOS doubles are 6 bytes */

>   strarray = (double *) malloc (NStrings * sizeof (char *));

>In this case, I've used an absurd unit to put on my array. I don't want an
>array of doubles any more than I want an array of characters! What I want,
>and need, is an array of pointers to characters!

You're right, this is an absurd example.  However, this is NOT what Ken
was doing with the array of integers.  It is NOT what I was doing with
strarray (in the example I claim is correct).  It is what Ken was doing
with his array of strings.  This usage BOTH of us agreed was wrong.

Quote:

>>-----

>>(insert-file ".disclaimer")
>>"I'm not an actor, but I play one on TV."

>------------------////////////////////\\\\\\\\\\\\\\\\\\\\------------------
>| Patrick Draper-ZBT       Disclaimer:  I can't control my fingers,        |

>| University of Michigan Computer Club                                     |
>NO CARRIER                     We are a nation of laws, not people         |
>------------------\\\\\\\\\\\\\\\\\\\\////////////////////------------------

--
-----

(insert-file ".disclaimer")
"I'm not an actor, but I play one on TV."


Sat, 16 Sep 1995 06:37:47 GMT  
 HELP! dynamic array of char*
Let me clear up this confusion. First of all, thanks to all the people
who banged me on the head and pointed out that an array of character
arrays is an array of char**. The code works now; thanks for the
pointers. (ha ha)

Second of all, I missed some messages in this thread, but whoever said
I was trying to put integer pointers into integers just didn't read my
original post. The integer example I posted originally was the correct
declaration and assignment for declaring an array of ints dynamically.
I was just trying to draw a parallel between that and doing the same
thing with strings; it was the double-dereference that got me. The
integer example was correct as I posted it.

Thanks again, all.

--


GEnie: K.FICARA / Compuserve: 71311,1461 / AOL: KENFICARA / Prodigy:(NOT!)



Sun, 17 Sep 1995 00:42:58 GMT  
 HELP! dynamic array of char*

Quote:

>You're right, this would be an error, but that's NOT what he was
>doing...  I quote the original message (his code got deleted in this
>thread):

Yes, you're correct. I mis-remembered the original example whan I followed
up to you. What I said would be correct for an array of pointers to
integers, but alas, twas only a pointer to integers.

Quote:

>>>(insert-file ".disclaimer")
>>>"I'm not an actor, but I play one on TV."

------------------////////////////////\\\\\\\\\\\\\\\\\\\\------------------
| Patrick Draper-ZBT       Disclaimer:  I can't control my fingers,        |

| University of Michigan Computer Club                                     |
NO CARRIER                     We are a nation of laws, not people         |
------------------\\\\\\\\\\\\\\\\\\\\////////////////////------------------


Sun, 17 Sep 1995 01:11:24 GMT  
 HELP! dynamic array of char*

Quote:

>I'm trying to dynamically declare an array of strings, and no matter
>what I do, I get errors.
[...]
>I declare

>    char    *strings;

>and then do

>    strings = (char*)malloc(NumberOfStrings * sizeof(char*));

>which gives me enough space for NumberOfStrings worth of pointers to
>characters, right? Okay.

...

Quote:

>But then I need to put something in those spaces, so I do

>    strings[index] = (char*)malloc(LengthOfString * sizeof(char));

>and I get an "illegal pointer arithmetic" error.

try:

        char **strings;

or to make the logic a little clearer:

        typedef char *string;
        string *strings;

        strings = (string *)malloc(NumberOfStrings * sizeof(string));
        strings[index] = (char *)malloc(LengthOfString * sizeof(char));

Oh, since malloc() should be defined in terms of char, the casts
and sizeof() in the second expression shouldn't be necessary.

Also remember to do (LengthOfString+1) to allow room for the
NUL character at the end of the string.

(This question is probably in the FAQ)

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
But I am frightened for you, children,          |
that the life that we are living is in vain,    |       -Richard Hartman        

has turned to rain....                          |



Sun, 17 Sep 1995 05:54:45 GMT  
 HELP! dynamic array of char*

Quote:
>Oh, since malloc() should be defined in terms of char, the casts
>and sizeof() in the second expression shouldn't be necessary.

  Not on my compiler.  malloc() returns a void *, not a char *.
And the sizeof IS necessary.  Don't assume sizeof(char) == 1 byte.

brian



Sun, 17 Sep 1995 08:55:11 GMT  
 HELP! dynamic array of char*

Quote:


>>Oh, since malloc() should be defined in terms of char, the casts
>>and sizeof() in the second expression shouldn't be necessary.
>  Not on my compiler.  malloc() returns a void *, not a char *.
>And the sizeof IS necessary.  Don't assume sizeof(char) == 1 byte.

  I've just received mail from someone telling me that the ANSI
standard requires sizeof(char) == 1 byte.

  How do NLS strings of characters from charsets like Kanji work with
this standard?  I've read about systems that use 2 or more bytes per
character.

brian



Sun, 17 Sep 1995 12:59:33 GMT  
 HELP! dynamic array of char*

Quote:


>>Oh, since malloc() should be defined in terms of char, the casts
>>and sizeof() in the second expression shouldn't be necessary.

>  Not on my compiler.  malloc() returns a void *, not a char *.
>And the sizeof IS necessary.  Don't assume sizeof(char) == 1 byte.

>brian

You CAN assume that sizeof(char)==1.

See page 204 - section A7.4.8 of K&R2 on the sizeof operator:
"... When sizeof is applied to a char, the result is 1; ...."

Having said that, IMHO it is still a good idea to include the sizeof(char),
simply to make one's intentions clear.




Sun, 17 Sep 1995 15:18:20 GMT  
 
 [ 25 post ]  Go to page: [1] [2]

 Relevant Pages 

1. help with function to create dynamic two-dimensional char array

2. HELP -> dynamic array of char** in dynamic array of mystruct**

3. finding chars in dynamic arrays

4. How to populate a dynamic array of strings (char*)

5. Differences between char array[SIZE] and char *array

6. Converting char array of literals chars to escape chars

7. A char pointer (char *) vs. char array question

8. HELP -> dynamic char** arrays (inside a dynamic struct**)

9. char array (array of array...) question

10. Dynamic arrays not really dynamic in managec C++?

11. dynamic array - newbie help

12. dynamic array help

 

 
Powered by phpBB® Forum Software