1

Hey everyone, thanks for taking the time to address my problem. I've looked at so much material at this point that I've just started getting more and more confused. Basically, I'm writing a simple segment of code that parses a string. Please understand that my question is NOT about parsing. I am using C++ and have never used C before and possess a little bit of c++ experience (introductory experience, I'm still a newbie).

struct parsedString{ char chunk1[50]; char chunk2[10]; char chunk3[50]; }; main(char* bigstring) { parsedString ps; ps = parseMe(bigString) cout << ps.chunk1 << endl; cout << ps.chunk2 << endl; cout << ps.chunk3 << endl; } parsedString parseMe(char* stringToParse) { char* parseStr = stringToParse; parsedString ps; ps.chunk1 = first x chars; ps.chunk2 = next y chars; ps.chunk3 = last z chars; return ps; }

Obviously this is not working code, I didn't want to throw up all the extra stuff since it would be tougher to read through and I'm pretty sure my problem is a newbie c/c++ problem and something about memory allocation or something like that...

Basically when the main function gets to printing the strings from the parsedString it prints out exactly what I want it to, plus garbage characters. I'm entering the values for each array ps.chunk using

ps.chunk1[i] = *parseStr

since parseStr gets me each individual character. I can't figure out where the garbage characters are coming from, does it have something to do with how I am accessing the big string? Originally I used char in the struct instead of arrays and when I printed from within the parseMe() function they would come out great but they would turn into gibberish when I accessed it from the main function. Any help is appreciated, thanks so much.

If something is unclear please let me know I'll do my best to elaborate.

Improve this question
6
  • it might actually be easier to see what the problem is if you put up the original code, my current guess is that the memory you are using is not zeroed out, try using memset to clear out the blocks of memory you are using in case it is recycled memory that has stuff left over. Also make sure you are using your pointers correctly as this could lead to a lot of problems if you don't check your boundaries correctly. Commented Mar 14, 2011 at 18:37
  • In C++, strings are manipulated as objects of type std::string. Char arrays are used for that purpose in C, and using them (in either language) could indeed be a confusing topic for a beginner. Is there a reason why strings cannot be used? Commented Mar 14, 2011 at 18:39
  • Are 50, 10 and 50 the actual sizes? Or is there an internal separator char in the incoming string? Please show an example of input and desired output. Commented Mar 14, 2011 at 18:53
  • I think I see, everyone seems to be pointing me to using strings instead :) is there a relatively easy way to parse a std::string by a delimiter (I think it's called tokenizing?)? Commented Mar 14, 2011 at 19:12
  • I followed Jesus Ramos's advice and used memset to zero out the memory that I was using, this solved the problem I was having. In the future I will use strings, and now I am set up to do so without too much redesign. Thanks everyone. Commented Mar 14, 2011 at 19:24

3 Answers 3

Reset to default
6

It's not clear why you're trying to do this with '\0' terminated strings, when C++ has a perfectly usable string class, but supposing some pedagogical reasons: are your strings '\0' terminated? How do you extract and copy the first x chars into ps.chunk1? How do you ensure that it has a '\0'?

If you really want to get exactly n characters, you have to:

assert(strlen(parseStr) >= n);

, copy them into the target (which must contain at least n+1 char's),

memcpy(ps.chunk1, parseStr, n);

, and add the final '\0':

ps.chunk1[n] = '\0';

(And, of course, advance parseStr: parseStr += n;)

Or you can simply use std::string everywhere, and write something like:

ps.chunk1(stringToParse.substr(startPosition, length));
Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Oh, I see what you're saying. I'm going to try using strings instead, I didn't realize it was so easy to convert the command-line-input char* to a string. I'll give it a shot.
1

As pointed out by others, you should use std::string to represent strings, and save yourself all the trouble. This could look like this:

struct parsedString{ std::string chunk1; std::string chunk2; std::string chunk3; }; parsedString parseMe(const std::stirng & stringToParse) { parsedString result; // just an example - this assigns the first two characters of stringToParse // to chunk1 result.chunk1 = stringToParse.substr(0, 2); // get the other chunks return result; // return the result }

The above code should illustrate the usage. You can find more information on std::string here.

Improve this answer

1 Comment

Thanks, I'll look into it and post back.
1

This could be happening due to a couple of reasons.

  • When you declare parsedString ps; it would be good to initialize the structure and make sure that you are receiving clean memory blocks to work with.parsedString ps = {0}; Some platforms don't do this and it's up to you to zero the memory before using it.

  • char* strings must end with the \0 character. This character signals the end of a char*. This is mandatory! Not inserting it at the end of the string will most probably make the print operation (for instance) display contents beyond the limits of the array giving you garbage characters. This is automatically achieved by zeroing all the struct as I suggest above.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.