Gandalf wrote:
Hello.
I thought that strlen was only available after adding
#include <string>
strlen() has nothing to do with <string>. strlen() is declared in
<string.h> or <cstring>. <string> is for the std::basic_string template
(from which std::string is created).
to my c++ program, but apperently not, or the compiler is
clever enough to find it by it self, or what?
If you want to use a function like strlen, you should #include the
appropriate header. Sometimes the correct header will be indirectly
#included through a different header, but you can't count on this.
The program compiles and runs fine on my Linx box, with
g++ version 2.95.4
Old version. Why are you using it?
Second question. Wouldn't the method, Set, result in that the char* text
will point to a newly allocated char array that is one char too short?
strlen ignores the final nullchar, and then the final null char will be
omitted in the copy procedure?
I'm not sure I understand that paragraph.
Regards.
----------------------
#include <iostream>
You need <string.h> or <cstring> here.
class Problem {
private:
char* text;
public:
Problem() {text=new char[1]; text='\0';}
This is not doing what you want it to do. First, you allocate a
character, then you immediately overwrite the pointer with 0, thus
leaking the allocated memory.
void prt() {cout<<text;}
It's called 'std::cout'.
void Set(char* str) {delete text; text=new char[strlen(str)];
strcpy(text,str);}
This is broken. You need another character to store the null terminator.
Your destination string is not large enough for the strcpy. The result
is undefined behavior - your program may crash, data may be corrupted,
it could behave erratically... anything could happen.
Also, you are deleting incorrectly. The memory 'text' points to was
allocated via new[], therefore it must be deallocated using delete[].
};
int main() {
Problem a;
Problem b;
Two memory leaks.
a.Set("Gandalf");
a.Set("Bigger Longer Uncut text");
Two cases of undefined behavior.
a.prt();
}
Other problems with your code:
* No destructor means you leak memory when an instance of your class
goes out of scope.
* The default copy constructor and copy assignment operator will cause a
new copy to have its 'text' pointer pointing to the exact same memory as
the original. When that happens, then one of the copies deletes the
memory 'text' pointed to, the other copy will point to memory that is no
longer valid, and will have no way of knowing that it's no longer valid.
Essentially anything you do with it at that point causes undefined behavior.
You should have avoided all these problems by using std::string instead
of C-style strings represented by char arrays.
I recommend you read the FAQ a few more times. You've obviously missed
several important points.
http://www.parashift.com/c++-faq-lite/
-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.
