Parsing a file you might need a switch-case with short strings, two to four letters on 32-bit systems, or even upto 8 letters on 64-bit. Using if would work, but looks ugly. Consider this:

std::string s("AACE");

if( s[0] == 'A' ) {
  if( s[1] == 'A' )
    ...
  else if( s[1] == 'C' )
    ...
  ...
} else if( s[0] == 'B' ) {
  ...
}

It gets ugly, doesn’t it?

A better solution, which shouldn’t harm endianness as long as it’s done on a single computer or the computers communicating use the same endianness:

enum
{
  AA = 'A'*0xFF+'A',
  AC = 'A'*0xFF+'C'
};

std::string s("AACE");
switch( s[0]*0xFF+s[1] )
{
  case AA:
    break;
  case AC:
    break;

  default:
    break;
}

You could write a macro to define the enums and doing this would be easier that way.. Also, you must make sure that the string is long enough!

I was told that the only case it wouldn’t work is when byte isn’t eight bits. I doubt it I’ll be running my code on a machine where byte isn’t eight bits…

Never access an std::string’s buffer with an intent to increase/decrease it’s length nor pass such a buffer to functions which takes a char*. I did this mistake sometime back and got trapped in a strange bug with operator +=. This is how my code looked.

std::string str( ' ', MAX_PATH );
GetFolderName( pFullPath, &str[0] ); // Oop

Problem with above code is that you won’t get an immediate crash since it’s a properly allocated buffer with MAX_PATH chars. But if you do further operations on such string expect plenty of inconsistencies. This is how my code looked after above piece of code…

str += "\\"; // Append backslash

I was expecting a valid path with backslash appended towards it’s end, but this never happened and debugging with debugger too didn’t help.

So now let me tell you what the exact problem is! When you do &str[0] you pass the address to the first char in std::string’s buffer. So when function GetFolderName fills in this buffer with folder path the length of std::string is not updated since it’s a C style function and it’s neither expected to do so. So the function terminates given buffer with a ” with std::string’s length way high (MAX_PATH). So now when I do a += std::string internally fails some condition leading to unexpected results, note that this piece of code never caused a crash but I was quite lucky and watchful enough to fix this stupid bug. Sigh!

So watchout, there is no CString::GetBuffer or CString::GetBufferSetLength type of function for std::string, well at least for now.

Que a biblioteca <iostream> oferece inúmeras facilidades para manipular I/O nós já sabemos mas, como converter um valor para uma std::string?

A bliblioteca <iostream> nos permite converter facilmente qualquer coisa para uma std::string usando a seguinte sintaxe (o exemplo a seguir converte um double, mas você pode substituir por qualquer coisa imprimível usando o operador <<):

#include <iostream>
#include <sstream>
#include <string>

std::string stringalizar(double x)
{
    std::ostringstream oss;
    oss << x;
    return oss.str();
} 

int main()
{
    std::string str;
    double dbl = -2.00655;

    str = stringalizar(dbl);

    std::cout << str << std::endl;
}

↓

O tipo std::ostringstream oferece facilidades de formatação assim como aquelas do std::cout. Nós podemos usar manipuladores e flags de formatação para controlar o formato do resultado, assim como podemos fazer com o std::cout.

Nesse exemplo, inserí x em oss pelo operador sobrecarregado de inserção <<. Isso invoca as facilidades do <iostream> para converter x em uma std::string.

A expressão oss.str() retorna uma std::string que contem o que foi inserido na stream oss, nesse caso, uma string com o valor de x.

Agora contrariando, ou fazendo o contrário

#include <iostream>
#include <sstream>
#include <string>

double converterParaDouble(std::string str)
{
    std::istringstream iss(str);
    double retorno;
    iss >> retorno;
    return retorno;
} 

int main()
{
    std::string str("261.15");
    double dbl = converterParaDouble(str);
    std::cout << dbl << std::endl;
}

↓
O tipo std::istringstream oferece facilidades de formatação assim como aquelas que std::cin oferece. Podemos usar modificadores e flags de formatação assim como em std::cin.

Nesse exemplo, nós inicializamos a std::string str com “261.15″ e passamos para nossa função de conversão. Na função nós inicializamos a std::istringstream iss passando a std::string str, então nós extraímos iss para retorno com o operador de extração >>. Isso nos provê as facilidades da <iostream> para converter a nossa string apropriadamente baseando-se no tipo da variável retorno.

Baseado em http://www.parashift.com/c++-faq-lite/index.html

I will describe in this post three ways to trim a string of given characters…

1. Using custom function for std::string
2. Using CString
3. Using StrTrim shell API function.

Using custom function for std::string

Its bit strange that std::string doesn’t provide a Trim function , but hey since we’ve got head upon our shoulders we’re gonna write one. . Here is a simple function which removes white space before and after a string. We’ll call it Trim!

void Trim( const std::string& StrToTrim, std::string& TrimmedString )
{
  // Find first non whitespace char in StrToTrim
  std::string::size_type First = StrToTrim.find_first_not_of( ' ' );
  // Check whether something went wrong?
  if( First == std::string::npos )
  {
    First = 0;
  }

  // Find last non whitespace char from StrToTrim
  std::string::size_type Last = StrToTrim.find_last_not_of( ' ' );
  // If something didn't go wrong, Last will be recomputed to get real length of substring
  if( Last != std::string::npos )
  {
    Last = ( Last + 1 ) - First;
  }

  // Copy such a string to TrimmedString
  TrimmedString = StrToTrim.substr( First, Last );
}

int main()
{
  std::string StrToTrim = " 32 Nibu babu thomas 2342 2 23 3 ";
  std::string TrimmedString = "On return will hold trimmed string";
  Trim( StrToTrim, TrimmedString );

  return 0;
}
//Output is: 32 Nibu babu thomas 2342 2 23 3

Using CString

Also CString has a Trim function, if you have the liberty to use CString then that’s another option.

Using StrTrim shell API function

Another option is to use StrTrim shell API function. Here is a demo from MSDN.

#include <windows .h>
#include <iostream .h>
#include "Shlwapi.h" 

void main(void)
{
  //String one
  TCHAR buffer[ ] = TEXT("_!ABCDEFG#");
  TCHAR trim[ ] = TEXT("#A!_"); 

  cout << "The string before calling StrTrim: ";
  cout << buffer;
  cout << "\n"; 

  StrTrim(buffer, trim); 

  cout << "The string after calling StrTrim: ";
  cout << buffer;
  cout << "\n";
} 

OUTPUT:
- - - - - -
The string before calling StrTrim: _!ABCDEFG#
The string after calling StrTrim: BCDEFG

Quite simple…

// A TCHAR based std::string
typedef std::basic_string<tchar> tstring;
// A TCHAR based std::ifstream;
typedef std::basic_ifstream</tchar><tchar , std::char_traits<TCHAR> > tstream;
// A TCHAR based std::stringstream
typedef std::basic_stringstream</tchar><tchar , std::char_traits<TCHAR>, std::allocator</tchar><tchar> > tstringstream;

So now no need to worry about UNICODE and ANSI, should work as CString, since TCHAR becomes char/wchar_t based on _UNICODE macro definition.

Also note that stl has provided UNICODE versions of these classes for e.g. wstring, wstringstream, wifstream, but since windows has a type that switches automagically between char/wchar_t, we are making use of it.

So the idea behind this is that stl classes are mostly template based, so this means you can add your own version of an stl class for a custom type just like I’ve done. As a conclusion we can say that std::string can be called a vector<char> but with dedicated string operations.

Apesar dos templates para hash_set e hash_map não serem padronizados, ambos são relativamente comuns, estando disponíveis tanto na implementação GNU (ie, no GCC) quanto no Visual C++ no Windows. Existem algumas diferenças, como o namespace um pouco mais escondido no GNUC (__gnu_cxx vs stdext) e alguns métodos que existem em um mas não em outro (p.ex.: reverse_iterator que não existe no GCC); mas a maioria das vezes servem para o serviço.

Um problema comum com essas classes no GCC é um erro meio criptico quando tentamos usar __gnu_cxx::hash_set<std::string> ou __gnu_cxx::hash_map<std::string>:

/usr/include/c++/4.2/ext/hashtable.h:595: error: no match for call to '(const __gnu_cxx::hash<std::basic_string<char, std::char_traits, std::allocator > >) (const std::basic_string<char, std::char_traits, std::allocator >&)'


Este erro ocorre porque a libstdc++ não define uma função de hash para std::string. A solução é definir uma (O RLY?). Felizmente a biblioteca padrão define uma função de hash para strings do tipo char*, então podemos aproveitá-la:

struct string_hash : public std::unary_function<std::string,size_t>
{
  size_t operator() (const std::string &v) const
  {
    return __gnu_cxx::hash()(v.c_str());
  }
};
typedef __gnu_cxx::hash_set<std::string,string_hash> string_hash_set;

Something i’ve found useful while programming in C++, is the use of std::stringstream to convert different datatypes to std::string. Fortunately, the process is the same for all types. That’s why a generic helper-function is preferable and will simplify the process considerably.

In order to use stringstreams, the library <sstream> has to be included. The following will create a reusable stringstream helper-function using templates.

template <typename T> std::string to_string(const T& value) {
std::stringstream os;
os << value;
return os.str();
}

The parameter contains the value that will be converted into a string, so you only have to assign a string to the function.

// assign a new string to the return value of to_string and show the contents
std::string str = to_string(5.12);
std::cout << str;