Today, I wrote a lot of code with a lot of errors (There's always a strange relationship between the two). The compiler misleadingly shows no errors, but when I run this program, there's some sort of "This program has performed an illegal operation" error sign, which I not much like. "If the problem persists, contact the program vendor", which, of course, is me, so that wasn't much help. When I debugged it, the debugger usually doesn't like my strings and arrays of strings and their respective pointers. Sometimes the problem is solved just by adding a set of []'s to the declaration statement, which temporarily revives my self esteem (after trying to solve it in ways that actually make sense millions of times -- adding []'s was something I tried hopelessly) My book is silent about this. Can anyone post common pitfalls with char arrays (in vc++) and how to solve them? Specifically I have a char* mystring = 0; Its contents will depend on users input inside a function (which I pass this string to). I then have yet another char char* arrayOfStrings[] = {0}; And this one will have plenty of mystring's , as in: arrayOfStrings[4] = mystring; mystring is run through a function many times, each time prompting for input which will them be stored to it, and later that mystring will be stored to arrayOfStrings as the next element. Debugger gots problems when I store something new in a string in statements such as: mystring[k] = *(userInput + j); Where k and j are just integers for whatever purpose which I happen to need. That may not be the source of the problem though -- might be in the defenition or what-not. Any ideas on what could POSSIBLY be wrong? ------------------------------------------------------------ .:<<-v0d[KA]->>:. [edited by - v0dKA on February 21, 2004 10:11:38 PM] [edited by - v0dKA on February 21, 2004 10:13:22 PM] [edited by - v0dKA on February 21, 2004 10:14:57 PM] [edited by - v0dKA on February 21, 2004 10:19:46 PM]

Common problems:

* buffer overruns
* dangling pointers
* memory leaks

char* mystring = 0; - That''s a null pointer, it''s not pointing to any data. Nor is there any memory allocated to store any data.

char* arrayOfStrings[] = {0}; - The array can hold at most one pointer. [] means the size of the array is determined by the number of elements in the initializer.

arrayOfStrings[4] = mystring; - Trying to write into the 5th array cell... OOOPS there is no such cell.

Debugger gots problems when I store something new in a string - not surprising, since you never reserve any room to store those strings

Solutions:
* learn how to use arrays
* learn how to use pointers
* learn how to use the standard C++ std::string class.
* learn how to make your freaking post even less readable.

“Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.” — Brian W. Kernighan (C programming language co-inventor)

Hello v0dKa,

I might be able to help. I've spent the last 3 months experimenting with pointers, characters, integers, and voids.

Firstly, if you have a character that looks like this:

char* mystring;

You can not write data to it without allocating memory. Now I learned a trick that can allocate but then yet de-reference the pointer when I am done with it in case you dont need that allocation more than once. Back to the *mystring, you can set it to a NULL pointer which will stop the string at that exact point. I could go on about NULL terminators, but I think they are very easy to follow.

Secondly, character arrays are different. You don't have to allocate them just write to them. For instance:

char arrayOfStrings[4] = {0};

The {0} just sets a NULL terminator to arrayOfStrings. In some cases you could write to your character like this:

strcpy(arrayOfStrings, "Cool");

Plus, for a handly tip, array's always start at 0, so you could write to your array also in this fashion:

arrayOfStrings[0] = 'C';
arrayOfStrings[1] = 'o';
arrayOfStrings[2] = 'o';
arrayOfStrings[3] = 'l';
arrayOfStrings[4] = '\0'; // null terminator

But thats the hard way, though I just wanted to show you how to do it like strcpy does.

Thirdly, you can not write a whole string to one character array unless you have a pointer array or a 2 by 2 array. For example:

arrayOfStrings[4] = mystring; // will not work

Because arrayOfStrings[4] as shown above can only handle one character like 'A' or 'a'. Now for the character array you can do:

char *myArray[2];

This will allow you to do the following:

char *myArray[2] = {"I am good at characters", "This stuff is awesome"};

Now myArray[0] will look like "I am good at characters". If you want to write over the existing array's you will need to allocate memory for these, for example:

// Writing to myArray[0]char newString[32];strcpy(newString, "This is a new string...");	// set newStringmyArray[0] = (char*) malloc (strlen(newString) + 1);	// + 1 for null terminatorif(myArray[0] != NULL) {	// if myArray is not NULL, then copy data.	strcpy( myArray[0], newString );}

Fourthly, mystring[k] can also only hold one character as in 'A' or 'a' for examples. Since my string is a regular character and not a pointer character array, you can only hold one letter per array number. So if you remembered to allocate *mystring, you could always set mystring[k] to equal 'A' or 'a'.

If you want to make mystring write a whole string per array do as mention above with myArray[2]. Since it has a pointer and an array you can write a string per array. Now for simpler terms you could do a 2 by 2 array looking like:

char myArray2[2][128];

To explain this one would be saying the following.:

myArray[n][sizeof(string)];

Like you could do:

strcpy(myArray[0], "This is awesome!");

and myArray[0] would look like "This is awesome!". No memory allocation is needed for these arrays.

Now for that trick about a temporary address to a pointer using an array would look like this:

char* myTrick() {	int index = 0;	static char myArray[1][1024];	strcpy(myArray[index], "This is a neat trick!");	return myArray[index];}int main() {	char* myString;	myString = myTrick();	printf("myString: %s\n", myString);	return 0;}

This is not to recommended at least not by most people, but for the cases that you want to get a string for that second and never worry about it later, this would help.

I hope all of this has helped, and if you have anymore questions feel free to ask.

- [BDS]StackOverflow



[edited by - BlueDev on February 23, 2004 1:17:51 PM]

quote:Original post by BlueDev
<snip>char arrayOfStrings[4] = {0};

The {0} just sets a NULL terminator to arrayOfStrings. In some cases you could write to your character like this:

strcpy(arrayOfStrings, "Cool");

Plus, for a handly tip, array's always start at 0, so you could write to your array also in this fashion:

arrayOfStrings[0] = 'C';
arrayOfStrings[1] = 'o';
arrayOfStrings[2] = 'o';
arrayOfStrings[3] = 'l';
arrayOfStrings[4] = '\0'; // null terminator

You're not allocating enough room for the string.
Like you strings are null terminated which means you have a bounds overflow.

quote:
<snip>char *myArray[2];

This will allow you to do the following:

char *myArray[2] = {"I am good at characters", "This stuff is awesome"};

Please use const char's when pointing to constant memory. I know it's not required but it's helpful to know that you cannot change this memory.

quote:
Now myArray[0] will look like "I am good at characters". If you want to write over the existing array's you will need to allocate memory for these, for example:

// Writing to myArray[0]char newString[32];strcpy(newString, "This is a new string...");	// set newStringmyArray[0] = (char*) malloc (strlen(newString) + 1);	// + 1 for null terminatorif(myArray[0] != NULL) {	// if myArray is not NULL, then copy data.	strcpy( myArray[0], newString );}

Again not enough to hold the null char.

quote:
<snip>

- [BDS]StackOverflow

Edit: Removes unmatched /quote in original post
My kingdom for a preview button.

[edited by - Wormy Hellcar on February 23, 2004 5:17:37 PM]

Well, I abandoned this post, and while reasonlessly checking through recent posts, I saw this one.

By now, I already learned std::string, but the trouble doesnt end here. I know most of the functions of it and how to use it and what not, but here''s my problem...

I declared an array of strings in main()...

string array[80];

Then sent it to an experimental function...

changeString(array);

But... here''s my problem. The return type is void, and yet I need to change the array from within the function. Passing a normal string as a reference in an argument is legal, but when I try it with the array of strings, it''s illegal. Pointers -- it''s legal, but from within the function the blasphemy starts. Here''s my code to attempt to change the array of strings (it doesn''t work)...

#include <iostream>using namespace std;// void change(string* array[]);// int main(){string terms[10];change(terms);return 0;}//void change(string* array[]){array[0] = "Bonjour";return;}

This returns two errors:

error C2664: ''change'' : cannot convert parameter 1 from ''class std::basic_string,class std::allocator > [10]'' to ''class std::basic_stringd::char_traits,class std::allocator > *[]''
Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

error C2440: ''='' : cannot convert from ''char [8]'' to ''class std::basic_string,class std::allocator > *''
Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

Suggestions?

------------------------------------------------------------
.:<<-v0d[KA]->>:.