concaténation de caractères const *

J'ai besoin de concaténer deux caractères const comme ceux-ci:

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

Comment pourrais-je faire ça?

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

Dans votre exemple, un et deux sont des pointeurs char, pointant vers des constantes char. Vous ne pouvez pas modifier les constantes char vers lesquelles pointent 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 distincte (tableau de caractères) pour contenir 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.

La voie C:

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

La manière C ++:

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

La méthode de compilation:

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

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

Si vous utilisez C ++, pourquoi n'utilisez-vous pas à la std::stringplace des 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, passez simplement three.c_str()

Utilisation std::string:

#include <string>

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

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

string total( string(one) + two );

// to use the concatenation as const char*, use:
total.c_str()

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

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

Encore un 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 spécifiquement utiliser la bibliothèque standard C ++, l'utilisation std::stringest probablement plus sûre.

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

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

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

Tout d'abord, vous devez créer un espace mémoire dynamique. Ensuite, vous pouvez simplement y insérer les deux chaînes. Ou vous pouvez utiliser la classe "string" c ++. La voie C à l'ancienne:

  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 méthode C ++

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

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

Vous pouvez utiliser strstream. C'est formellement obsolète, mais c'est toujours un excellent outil si vous devez 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';

Cela écrira one, puis twodans le flux, et ajoutera une fin en \0utilisant std::ends. Au cas où les deux chaînes pourraient finir par écrire exactement des 99caractères - il ne resterait donc plus d'espace d'écriture \0- nous en écrivons une manuellement à la dernière position.

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

Connexion de deux pointeurs de caractères constants sans utiliser la commande strcpy dans l'allocation dynamique de la 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;