const char * concaténation

Question

Je dois concaténer deux caractères const comme celles-ci:

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

Comment pourrais-je aller sur le faire?

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

Answer 1

Dans votre exemple un et deux sont des pointeurs char, pointant char constantes. Vous ne pouvez pas modifier les constantes char pointé 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 tenir le résultat. Quelque chose comme ceci:

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.

Answer 2

Le chemin C:

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

Le C ++ façon:

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

La façon de compilation:

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

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

Answer 3

Si vous utilisez C ++, pourquoi ne pas utiliser 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 transmettre cette chaîne à une fonction C, il suffit de passer three.c_str()

Answer 4

Utilisation std::string:

#include <string>

std::string result = std::string(one) + std::string(two);

Answer 5

Mise à jour: changé     string total = string(one) + string(two); à string total( string(one) + two ); pour des raisons de performance (évite la construction de deux cordes et totale de 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()

Answer 6

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 voulez pas spécifiquement ou ne peut pas utiliser la bibliothèque standard C de l'aide std::string est probablement plus sûr.

Answer 7

Il semble que vous utilisez C ++ avec une bibliothèque C et donc vous devez travailler avec const char *.

Je suggère envelopper les const char * dans std::string:

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

Answer 8

Tout d'abord, vous devez créer un espace de mémoire dynamique. Ensuite, vous pouvez juste StrCat les deux chaînes en elle. Vous pouvez également utiliser le c ++ classe « string ». L'ancienne école C:

  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 C ++ façon

  std::string three(one);
  three += two;

Answer 9

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;
}

Answer 10

Vous pouvez utiliser strstream. Il est formellement déconseillé, mais il est encore un excellent outil si vous avez besoin de travailler avec des chaînes C, je pense.

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

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

rédigera one puis two dans le flux, et ajouter un \0 de terminaison à l'aide std::ends. Dans le cas où les deux chaînes pourraient finir par écrire des caractères exactement 99 - donc pas d'espace serait laissé par écrit \0 - nous écrivons une main à la dernière position.

Answer 11

const char* one = "one";
const char* two = "two";
char result[40];
sprintf(result, "%s%s", one, two);

Answer 12

Connexion deux pointeur char constant 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;