Já que mencionaste a procura, qualquer que seja a escolha da biblioteca que faças, strchr e strstr são quase de certeza que vão ser o que queres usar. strspn e strcspn também podem sê útil.

Se você realmente quiser obtê-lo desde o início, você deve olhar para ICU, ou seja, Suporte Unicode, a menos que você esteja certo as suas cordas nunca irão conter nada além de simples ASCII-7... Procurar, expressões regulares, tokenization está tudo aí.

Claro que ir para C++ tornaria as coisas muito mais fáceis , mas mesmo assim a minha recomendação da UCI manter-se-ia.

Por favor verifique as milkstrings.
Código Da Amostra:

int main(int argc, char * argv[]) {
  tXt s = "123,456,789" ;
  s = txtReplace(s,"123","321") ; // replace 123 by 321
  int num = atoi(txtEat(&s,',')) ; // pick the first number
  printf("num = %d s = %s \n",num,s) ;
  s = txtPrintf("%s,%d",s,num) ; // printf in new string
  printf("num = %d s = %s \n",num,s) ;
  s = txtConcat(s,"<-->",txtFlip(s),NULL) ; // concatenate some strings
  num = txtPos(s,"987") ; // find position of substring
  printf("num = %d s = %s \n",num,s) ;
  if (txtAnyError()) { //check for errors
    printf("%s\n",txtLastError()) ;
    return 1 ; }
  return 0 ;
  }

Também encontrei a necessidade de uma biblioteca de cordas c externa, pois considero as funções {[[0]} Muito pouco eficientes, por exemplo:

• strcat() pode ser muito caro no desempenho, pois tem que encontrar o '\0' cada vez que você concatenate uma string
• strlen() é caro, como de novo, tem de encontrar o' \0 ' char em vez de apenas ler uma variável mantida length
O array char não é dinâmico e pode causar erros muito perigosos. pode ser o bom cenário quando você transborda seu buffer)

A solução deve ser uma biblioteca que não contém apenas funções, mas também contém uma estrutura que envolve a cadeia e que permite armazenar campos importantes, tais como length e buffer-size

1. GLib String library (should be best standard solution) - https://developer.gnome.org/glib/stable/glib-Strings.html
2. http://locklessinc.com/articles/dynamic_cstrings/
3. http://bstring.sourceforge.net/

Eu enfrentei este problema recentemente, a necessidade de adicionar uma string com milhões de caracteres. Acabei por fazer o meu próprio.

É simplesmente um array C de caracteres, encapsulado em uma classe que mantém o controle do tamanho do array e número de bytes alocados.

O desempenho em comparação com SDS e std:: string é 10 vezes mais rápido com o valor de referência abaixo

Em

Https://github.com/pedro-vicente/table-string

Marcos de Referência

Para Visualização Studio 2015, x86 debug build:

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

clock_gettime_t timer;
const size_t nbr = 1000 * 1000 * 10;
const char* s = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
size_t len = strlen(s);
timer.start();
table_str_t table(nbr *len);
for (size_t idx = 0; idx < nbr; ++idx)
{
  table.add(s, len);
}
timer.now("end table");
timer.stop();

Editar O desempenho máximo é alcançado atribuindo a cadeia de caracteres todos no início (Tamanho do parâmetro construtor). Se for utilizada uma fracção do tamanho total, o desempenho diminui. Exemplo com 100 atribuições:

std::string benchmark append string of size 33, 10000000 times
end str:        11.0 seconds    11.0 total
std::string reserve benchmark append string of size 33, 10000000 times
end str reserve:        10.0 seconds    10.0 total
table string benchmark with pre-allocation of 330000000 elements
end table:      1.0 seconds     1.0 total
table string benchmark with pre-allocation of ONLY 3300000 elements, allocation is MADE 100 times...patience...
end table:      9.0 seconds     9.0 total