(Tutorial) Crashproof C++ Language

Use const at every opportunity

Const is your most powerful anti-crash weapon. Use it at every opportunity. An additional benefit is that it makes your code self-documenting. For instance, look at this:

const char *add2strings(const char *sz1, const char *sz2);

Such a declaration guarantee's that no matter what wierd things go on within the function, it can't harm the application programmer's two strings sz1 and sz2. If any memory corruption occurs, it will be to variables within the function's scope. This, of course, greatly reduces side effect bugs. Of course, if the program has global variables, all bets are off...

Furthermore, the declaration of the return pointer as const means that the application programmer can't "reach inside" the function to corrupt its scope. For instance, if the return value is a static array of 40 characters, if the return wasn't static the application programmer could do this:

char *pchName = add2strings("Philbinoff", "James");
strcat(pchName, " is the name of the first author of the three books");
cout << "I just corrupted an internal variable of add2strings. ";
cout << "Will I see this message?\n";
cout << "Will it crash later in the program? Who knows!\n";

Fortunately, because add2strings() returns a const pointer, you'll get a compiler error on this:

char *pchName = add2strings("Philbinoff", "James");

Even if you declared pchName as a const char *, the moment you modified its contents with strcat() you'd get a compile error. The const keyword helps the programmer keep any errors localized, thus greatly reducing the likelihood of side-effect errors.

Be very careful with string manipulation

My experience tells me the number one cause of "memory tromp" -- hangs, GPF's and other nasty and hard to find problems, is string manipulation. In the bad-old-days of C, this was unavoidable. Now, it shouldn't be a problem.

If you can, make a string class

Have you ever used strings in other languages? Isn't it nice? The penalty for a mistake is not a GPF on the other side of the program that occurs in some sites but not others. In other languages either it works or it doesn't, but you know right away. You can achieve the same level of confidence in your strings by using a string class.

There are many implementations of string classes. Stroustrup describes a simple one in chapter/section 7.11 of his book, The C++ Programming Language, Second Edition (ISBN0-201-53992-6). Your organization may make its own. Whatever you use, it should have provisions to output to and input from streams, concatenate, search/replace, etc, WITHOUT the application programmmer having to resort to pointer arithmetic. Such an implementation might use the plus sign for concatenation.

The Poor Man's String Class

If your organization hasn't made a string class, you can have many of the benefits by using C++ string streams. A string steam is a stream that writes to a string instead of a file. You can declare it without giving a maximum length, and you can keep appending strings to it. For instance:

//***** Create nametag string ******
ostrstream ost; 
ost << "My name is " << ychFname;
ost.put(0);                  //null terminate the string 
makenametag(ost.str());

//***** Also create a nametag with the last name after first *****
ost.seekp(ost.tellp()-1);    //get rid of the null termination
ost << " " << ychLname;
ost.put(0);                  //null terminate the string
makenametag(ost.str());

[Read more..]

Courtesy : Troubleshooters.com