concatene cadena de caracteres en C++

Question

¿Cómo puedo concatenar dos cadenas de caracteres?

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <iostream> 
#include <fstream> 
#include <sstream> 
#include <string> 
#include "types.h"  

int main() { 
    char dest[1020] = "you"; 
    char source[7] = "baby"; 
    stringstream a,b; 
    a << source; 
    b << dest; 
    a << b; /*HERE NEED CONCATENATE*/ 
    cout << a << endl; 
    cout << a.str() << endl; 
    return 0; 
} 

La salida es la siguiente en ambos tries:

0xbf8cfd20 
baby0xbf8cfddc 

la salida deseada es babyyou.

Answer 1

debe ser:

b << dest; 
a << b.str(); 

stringstream::str devuelve la cadena subyacente en el stringstream.

Answer 2

Basta con sustituir a << b con a << b.str()

Answer 3

Más genéricamente iostreams través de:

std::istream is1, is2; // eg. (i)stringstream 
std::ostream os;  // eg. (o)stringstream 

os << is1.rdbuf(); 
os << is2.rdbuf(); 
os << std::flush; 

Esto funciona para FileStreams, std :: cin etc., así como para stringstream

Answer 4

O

a << b.rdbuf(); 

siempre que obtenga el puntero es o n el comienzo de la secuencia para evitar asignar otro std::string más para el contenido.

Answer 5

No necesita dos instancias de std::stringstream. Una es suficiente para el propósito.

std::stringstream a; 
a << source << dest; 

std::string s = a.str(); //get the underlying string 

Answer 6

La pregunta era "cómo concatenar Streams", las respuestas explican cómo concatenar el contenido de los cursos de agua. Aquí es una clase que puede ser usado para concatenar dos iStreams en uno istream (ConcatStreams.h archivo):

class ConcatStreams 
: public std::streambuf { 
std::streambuf* sbuf1_; 
std::streambuf* sbuf2_; 
char*   buffer_; 
int useBuf; 
int bufSize; 
public: 
ConcatStreams(std::streambuf* sbuf1, std::streambuf* sbuf2) 
    : bufSize(1024), sbuf1_(sbuf1), sbuf2_(sbuf2), buffer_(new char[bufSize]), useBuf(1) { 
} 
ConcatStreams(const ConcatStreams& orig); 
virtual ~ConcatStreams() { delete[] this->buffer_; } 
int underflow() { 
    if (this->gptr() == this->egptr()) { 
     // get data into buffer_, obtaining its input from 
     // this->sbuf_; if necessary resize buffer 
     // if no more characters are available, size == 0. 
     std::streamsize size=0; 
     if(useBuf==1) { 
      size = this->sbuf1_->sgetn(this->buffer_, bufSize); 
      if(!size) { useBuf++;} 
     } 
     if(useBuf==2) { 
      size = this->sbuf2_->sgetn(this->buffer_, bufSize); 
      if(!size) { useBuf++;} 
     } 
     this->setg(this->buffer_, this->buffer_, this->buffer_ + size); 
    } 
    return this->gptr() == this->egptr() 
     ? std::char_traits<char>::eof() 
     : std::char_traits<char>::to_int_type(*this->gptr()); 
} 
}; 

utilizarlo:

#include "ConcatStreams.h" 
istringstream msgIn1("this is a stream."); 
istringstream msgIn2("this is another stream."); 
ConcatStreams cs(msgIn1.rdbuf(), msgIn2.rdbuf()); 
istream msgIn(&cs); 
cout << "'" << msgIn.rdbuf() << "'" << endl; 

Básicamente utiliza la clase de los streambuf de las corrientes pasaron para crear un nuevo streambuf que primero lea el primer streambuf y luego lea el segundo streambuf cuando termine con el primero.