web-dev-qa-db-fra.com

const char * concaténation

J'ai besoin de concaténer deux caractères const de ce type:

const char *one = "Hello ";
const char *two = "World";

Comment pourrais-je m'y prendre?

Je reçois ces char*s d'une bibliothèque tierce avec une interface en C, je ne peux donc pas simplement utiliser std::string à la place.

c++cstring-concatenation
98
Anthoni Caldwell

Dans votre exemple un et deux sont des pointeurs de caractère, pointant vers des constantes de caractère. Vous ne pouvez pas modifier les constantes de caractère pointées par ces pointeurs. Donc, quelque chose comme:

strcat(one,two); // append string two to string one.

ne fonctionnera pas. Au lieu de cela, vous devriez avoir une variable séparée (tableau de caractères) pour conserver le résultat. Quelque chose comme ça:

char result[100];   // array to hold the result.

strcpy(result,one); // copy string one into the result.
strcat(result,two); // append string two to the result.
90
codaddict

La voie C:

char buf[100];
strcpy(buf, one);
strcat(buf, two);

La manière C++:

std::string buf(one);
buf.append(two);

La manière de compiler:

#define one "hello "
#define two "world"
#define concat(first, second) first second

const char* buf = concat(one, two);
68
Idan K

Si vous utilisez C++, pourquoi n'utilisez-vous pas std::string au lieu de chaînes de style C?

std::string one="Hello";
std::string two="World";

std::string three= one+two;

Si vous devez passer cette chaîne à une fonction C, il suffit de passer three.c_str()

30
Prasoon Saurav

Utiliser std::string:

#include <string>

std::string result = std::string(one) + std::string(two);
18
Gregory Pakosz

Mise à jour: modifié string total = string(one) + string(two);to string total( string(one) + two ); pour des raisons de performances (évite la construction de la chaîne 2 et le total de la chaîne temporaire)

const char *one = "Hello ";
const char *two = "World";

string total( string(one) + two );    // OR: string total = string(one) + string(two);
// string total(move(move(string(one)) + two));  // even faster?

// to use the concatenation in const char* use
total.c_str()
16
Pedro Reis

Un autre exemple:

// calculate the required buffer size (also accounting for the null terminator):
int bufferSize = strlen(one) + strlen(two) + 1;

// allocate enough memory for the concatenated string:
char* concatString = new char[ bufferSize ];

// copy strings one and two over to the new buffer:
strcpy( concatString, one );
strcat( concatString, two );

...

// delete buffer:
delete[] concatString;

Mais à moins que vous ne vouliez ou ne puissiez pas utiliser la bibliothèque standard C++, utiliser std::string est probablement plus sûr.

7
stakx

Tout d'abord, vous devez créer un espace mémoire dynamique. Ensuite, vous pouvez simplement strcat les deux chaînes en elle. Ou vous pouvez utiliser la classe "chaîne" c ++. Le chemin de la vieille école:

  char* catString = malloc(strlen(one)+strlen(two)+1);
  strcpy(catString, one);
  strcat(catString, two);
  // use the string then delete it when you're done.
  free(catString);

Nouvelle manière C++

  std::string three(one);
  three += two;
5
Paul Tomblin

On dirait que vous utilisez C++ avec une bibliothèque C et que vous devez donc utiliser const char *.

Je suggère d'encapsuler ces const char * dans std::string:

const char *a = "hello "; 
const char *b = "world"; 
std::string c = a; 
std::string d = b; 
cout << c + d;
5
Luca Matteis

Si vous ne connaissez pas la taille des chaînes, vous pouvez faire quelque chose comme ceci:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(){
    const char* q1 = "First String";
    const char* q2 = " Second String";

    char * qq = (char*) malloc((strlen(q1)+ strlen(q2))*sizeof(char));
    strcpy(qq,q1);
    strcat(qq,q2);

    printf("%s\n",qq);

    return 0;
}
4
Anoroah

Vous pouvez utiliser strstream. C'est formellement obsolète, mais c'est quand même un excellent outil si vous devez travailler avec des chaînes en C, je pense.

char result[100]; // max size 100
std::ostrstream s(result, sizeof result - 1);

s << one << two << std::ends;
result[99] = '\0';

Ceci écrira one et ensuite two dans le flux, et ajoutera un \0 final utilisant std::ends. Si les deux chaînes finissaient par écrire exactement les caractères 99 - il ne resterait donc plus d'espace - \0 - nous en écrivons un manuellement à la dernière position. 

3
Johannes Schaub - litb
const char* one = "one";
const char* two = "two";
char result[40];
sprintf(result, "%s%s", one, two);
3
Jagannath

Connexion de deux pointeurs de caractères constants sans utiliser la commande strcpy dans l'allocation dynamique de mémoire:

const char* one = "Hello ";
const char* two = "World!";

char* three = new char[strlen(one) + strlen(two) + 1] {'\0'};

strcat_s(three, strlen(one) + 1, one);
strcat_s(three, strlen(one) + strlen(two) + 1, two);

cout << three << endl;

delete[] three;
three = nullptr;
0
Edin Jašarević