cstring makes string.h accessable in namnespace std. cstring is located
in /usr/include/c++ in my case. If you can't find it, just look for it
It should be in a subdir of /usr/include
The file contains a comment, which might be useful:
/** @file cstring
* This is a Standard C++ Library file. You should @c #include this file
* in your programs, rather than any of the "*.h" implementation files.
* This is the C++ version of the Standard C Library header @c string.h,
* and its contents are (mostly) the same as that header, but are all
* contained in the namespace @c std.
The Microsoft CString was written before the STL (and thus before std::string), but they are both designed to do basically the same thing.
The STL string has better out-of-the-box interoperability with STL algorithms.
The MS string has some really nice member functions.
Choose the one that suits your needs best.
Efficient in what sense?
the std::string will allow you to program more efficiently in terms of how you manage your time. Of course you can use it incorrectly and write really bad programs regardless of whether you define strings as char arrays or std::string objects. I just don't think that it is a fair question to be honest with you. Try defining some requirements. Write the program once with only c strings and once with std::string. Profile both programs and also keep track of how much time you spent writing each program. Look at the generated assembly code for each. There are a lot of factors to consider. Then report to us which is more efficient.
If you're using MFC, CString is a far better choice over std::string.
IMHO, CString is the only MFC class that is better then the STL version.
The std::string that comes with VC++ 6.0/7.x is very inefficient compare to CString.
std::string peforms very badly compare to CString.
Also IMHO, CString has a better string interface then std::string does.
CString is also easier to code when you want to be able to compile a project to either UNICODE or ANSI.
CString has an operator LPCTSTR(), so you don't have to explicitly cast.
With std::string, you have to use the c_str() member function to pass the pointer.
This point can also be consider a CON, but IMHO, the benifit far aways the down side.
CString has a GetBuffer() function which allows you to modify the buffer directly.
According to the C++ standard there's no portable way to modify the std::string buffer directly.
CString has a CompareNoCase function so you can make case insensitive comparisons.
CString works easier with many MFC and Windows API functions.
The major CON with CString is that is not portable. However, there are some CString versions on the net that are portable.
> > C headers exist in C++ in the form
Your understanding is correct. The safe rule is that if you want the
names to be in the global namespace, use
be in std::, use