한 줄에 여러 C ++ 문자열을 어떻게 연결합니까?


150

C #에는 많은 데이터 형식을 한 줄에 함께 연결할 수있는 구문 기능이 있습니다.

string s = new String();
s += "Hello world, " + myInt + niceToSeeYouString;
s += someChar1 + interestingDecimal + someChar2;

C ++에서 동등한 것은 무엇입니까? 내가 볼 수있는 한 + 연산자로 여러 문자열 / 변수를 지원하지 않기 때문에 별도의 줄에서 모두 수행해야합니다. 이것은 괜찮지 만 깔끔하게 보이지는 않습니다.

string s;
s += "Hello world, " + "nice to see you, " + "or not.";

위의 코드는 오류를 생성합니다.


4
다른 곳에서 설명했듯이 "+ 연산자로 여러 문자열 / 변수를 지원하지 않기"때문이 아니라 char *서로 포인터를 추가하려고하기 때문 입니다. 합산 포인터는 무의미하기 때문에 오류가 발생합니다. 아래에서 언급했듯이 적어도 첫 번째 피연산자를로 만들면 std::string오류가 없습니다.
underscore_d

어떤 오류가 발생 했습니까?
Wolf

답변:


240
#include <sstream>
#include <string>

std::stringstream ss;
ss << "Hello, world, " << myInt << niceToSeeYouString;
std::string s = ss.str();

Herb Sutter : Manor Farm의 String Formatters 의이 Guru Of The Week 기사를 살펴보십시오.


6
이것을보십시오 :std::string s = static_cast<std::ostringstream&>(std::ostringstream().seekp(0) << "HelloWorld" << myInt << niceToSeeYouString).str();
Byzantian

42
ss << "와우, C ++에서의 문자열 연결은 인상적입니다"<< "
joaerl

4
다른 방법으로 이름을 지정하려면 여러 추가를 사용하십시오. string s = string ( "abc"). append ( "def"). append (otherStrVar) .append (to_string (123));
Patricio Rossi

1
std::stringstream ss; ss << "Hello, world, " << myInt << niceToSeeYouString; std::string s = ss.str();거의 한 줄입니다
Kotauskas

74

5 년 안에 아무도 언급하지 않았 .append습니까?

#include <string>

std::string s;
s.append("Hello world, ");
s.append("nice to see you, ");
s.append("or not.");

한 줄에 텍스트를 추가하는 것과 비교하면 번거롭기 때문입니다.
Hi-Angel

11
s.append("One"); s.append(" line");
Jonny

16
@Jonny s.append("One").append(" expression");반환 값을 이런 식으로 사용하려면 원본을 편집해야합니까?
시조

5
@ SilverMöls OP는 s동등한 C # 코드와 비 컴파일 C ++ 코드에서 다른 줄에 선언 합니다. 그의 원하는 C ++는 다음 s += "Hello world, " + "nice to see you, " + "or not.";과 같이 작성 될 수 있습니다.s.append("Hello world, ").append("nice to see you, ").append("or not.");
Eponymous

4
주요 장점은 append문자열에 NUL 문자가 포함 된 경우에도 작동한다는 것입니다.
John S.

62
s += "Hello world, " + "nice to see you, " + "or not.";

이러한 문자 배열 리터럴은 C ++ std :: strings가 아닙니다. 변환해야합니다.

s += string("Hello world, ") + string("nice to see you, ") + string("or not.");

int (또는 다른 스트리밍 가능한 유형)를 변환하려면 lexical_cast를 사용하거나 자체 기능을 제공 할 수 있습니다.

template <typename T>
string Str( const T & t ) {
   ostringstream os;
   os << t;
   return os.str();
}

이제 다음과 같이 말할 수 있습니다.

string s = string("The meaning is ") + Str( 42 );

16
첫 번째 문자열 만 명시 적으로 변환하면됩니다. s + = string ( "Hello world,") + "반갑습니다."+ "또는 아닙니다.";
Ferruccio 2016 년

8
예,하지만 이유를 설명 할 수 없었습니다!

1
boost :: lexical_cast-Str 함수에서 훌륭하고 비슷 함 :)
bayda

2
생성자 오른쪽에서 수행 된 연결 은 클래스에 정의 된 것을 string("Hello world")통해 수행됩니다 . 표현식에 객체 가없는 경우 연결은 단순한 문자 포인터의 합이 됩니다. operator+()stringstringchar*
davide

41

코드는 1 로 쓸 수 있습니다 .

s = "Hello world," "nice to see you," "or not."

...하지만 그것이 당신이 찾고있는 것 의심합니다. 귀하의 경우에는 아마도 스트림을 찾고있을 것입니다.

std::stringstream ss;
ss << "Hello world, " << 42 << "nice to see you.";
std::string s = ss.str();

1 " " 로 쓸 수 있습니다 : 이것은 문자열 리터럴에만 작동합니다. 연결은 컴파일러에 의해 수행됩니다.


11
첫 번째 예제는 언급 할 가치가 있지만, "연결"리터럴 문자열 (컴파일러 자체가 연결을 수행하는 경우)에만 작동한다는 점도 언급하십시오.
j_random_hacker 2016 년

문자열이 이전에 다음과 같이 선언 된 경우 첫 번째 예에서 오류가 발생 const char smthg[] = "smthg"했습니다. 버그입니까?
Hi-Angel

@ Hi-Angel 불행히도 대신 #define문자열을 해결할 수는 있지만 자체 문제가 있습니다.
cz

27

C ++ 14 사용자 정의 리터럴을 사용 std::to_string하면 코드가 쉬워집니다.

using namespace std::literals::string_literals;
std::string str;
str += "Hello World, "s + "nice to see you, "s + "or not"s;
str += "Hello World, "s + std::to_string(my_int) + other_string;

연결시 문자열 리터럴을 컴파일 할 때 수행 할 수 있습니다. 를 제거하십시오 +.

str += "Hello World, " "nice to see you, " "or not";

2
11 ++ C 때문에 당신은 표준 : to_string 사용할 수 있습니다
파트 리 로시

C ++ 11 <> 이후에도 사용자 정의 리터럴 . 편집했습니다.
Stack Danny

@StackDanny 변경이 잘못되었습니다. "C ++ 14"라고 말하면 std::literals::string_literalsUDL의 개념이 아니라을 말합니다 .
Rapptz

16

한 줄로 된 솔루션을 제공하려면 : concat"클래식"문자열 스트림 기반 솔루션을 단일 명령문 으로 줄이기 위한 기능 을 구현할 수 있습니다 . 다양한 템플릿과 완벽한 전달을 기반으로합니다.


용법:

std::string s = concat(someObject, " Hello, ", 42, " I concatenate", anyStreamableType);

이행:

void addToStream(std::ostringstream&)
{
}

template<typename T, typename... Args>
void addToStream(std::ostringstream& a_stream, T&& a_value, Args&&... a_args)
{
    a_stream << std::forward<T>(a_value);
    addToStream(a_stream, std::forward<Args>(a_args)...);
}

template<typename... Args>
std::string concat(Args&&... a_args)
{
    std::ostringstream s;
    addToStream(s, std::forward<Args>(a_args)...);
    return s.str();
}

큰 코드베이스에 여러 가지 다른 조합이 있으면 컴파일 타임 팽창이되지 않습니다.
Shital Shah

1
@ShitalShah는 이러한 도우미 함수가 어쨌든 인라인되기 때문에 수동으로 해당 인라인을 작성하는 것 이상입니다.
underscore_d

13

C ++ 20에서는 다음을 수행 할 수 있습니다.

auto s = std::format("{}{}{}", "Hello world, ", myInt, niceToSeeYouString);

그때까지 {fmt} 라이브러리를 사용 하여 동일한 작업을 수행 할 수 있습니다 .

auto s = fmt::format("{}{}{}", "Hello world, ", myInt, niceToSeeYouString);

면책 조항 : 저는 {fmt}의 저자입니다.


7

부스트 :: 형식

또는 std :: stringstream

std::stringstream msg;
msg << "Hello world, " << myInt  << niceToSeeYouString;
msg.str(); // returns std::string object

6

그만큼 실제 문제는 문자열 리터럴을 연결하기로이었다 +++ C에 실패

string s;
s += "Hello world, " + "nice to see you, " + "or not.";
위의 코드는 오류를 생성합니다.

C ++ (C에서도)에서는 문자열 리터럴을 서로 바로 옆에 배치하여 연결합니다.

string s0 = "Hello world, " "nice to see you, " "or not.";
string s1 = "Hello world, " /*same*/ "nice to see you, " /*result*/ "or not.";
string s2 = 
    "Hello world, " /*line breaks in source code as well as*/ 
    "nice to see you, " /*comments don't matter*/ 
    "or not.";

매크로로 코드를 생성하는 경우이 방법이 적합합니다.

#define TRACE(arg) cout << #arg ":" << (arg) << endl;

... 이처럼 사용할 수있는 간단한 매크로

int a = 5;
TRACE(a)
a += 7;
TRACE(a)
TRACE(a+7)
TRACE(17*11)

( 실시간 데모 ... )

또는 +for 문자열 리터럴을 사용해야한다고 주장하는 경우 ( underscore_d에서 이미 제안한 것처럼) ) :

string s = string("Hello world, ")+"nice to see you, "+"or not.";

다른 솔루션은 const char*각 연결 단계마다 문자열과

string s;
s += "Hello world, "
s += "nice to see you, "
s += "or not.";

또한이 기술을 많이 사용하지만 하나 이상의 변수가 int / string 인 경우 어떻게됩니까? .eg 문자열 s = "abc" "def"(int) y "ghi"(std :: string) z "1234"; 그렇다면 sprintf는 여전히 최악의 솔루션입니다.
Bart Mensfort

@BartMensfort는 물론 sprintf옵션이지만, 크기가 작은 버퍼의 문제를 방지하는 std :: stringstream 도 있습니다 .
Wolf


3

문자열에 적용하려는 모든 데이터 유형에 대해 operator + ()를 정의해야하지만 operator <<는 대부분의 유형에 대해 정의되므로 std :: stringstream을 사용해야합니다.

젠장, 50 초 뛰고 ...


1
실제로 char 및 int와 같은 내장 유형에서는 새 연산자를 정의 할 수 없습니다.
Tyler McHenry

1
@TylerMcHenry이 경우에 권장하지는 않지만 확실히 할 수있는 일 :std::string operator+(std::string s, int i){ return s+std::to_string(i); }
Eponymous

3

를 쓰면 +=C #과 거의 같습니다.

string s("Some initial data. "); int i = 5;
s = s + "Hello world, " + "nice to see you, " + to_string(i) + "\n";

3

다른 사람들이 말했듯이 OP 코드의 주요 문제점은 운영자 +가 연결하지 않는다는 것입니다 const char *. std::string그래도 작동합니다 .

다음은 C ++ 11 람다를 사용 하고 문자열을 분리 for_each할 수있는 또 다른 솔루션입니다 separator.

#include <vector>
#include <algorithm>
#include <iterator>
#include <sstream>

string join(const string& separator,
            const vector<string>& strings)
{
    if (strings.empty())
        return "";

    if (strings.size() == 1)
        return strings[0];

    stringstream ss;
    ss << strings[0];

    auto aggregate = [&ss, &separator](const string& s) { ss << separator << s; };
    for_each(begin(strings) + 1, end(strings), aggregate);

    return ss.str();
}

용법:

std::vector<std::string> strings { "a", "b", "c" };
std::string joinedStrings = join(", ", strings);

적어도 내 컴퓨터에서 빠른 테스트를 한 후에는 (선형 적으로) 잘 확장되는 것 같습니다. 다음은 내가 작성한 빠른 테스트입니다.

#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <chrono>

using namespace std;

string join(const string& separator,
            const vector<string>& strings)
{
    if (strings.empty())
        return "";

    if (strings.size() == 1)
        return strings[0];

    stringstream ss;
    ss << strings[0];

    auto aggregate = [&ss, &separator](const string& s) { ss << separator << s; };
    for_each(begin(strings) + 1, end(strings), aggregate);

    return ss.str();
}

int main()
{
    const int reps = 1000;
    const string sep = ", ";
    auto generator = [](){return "abcde";};

    vector<string> strings10(10);
    generate(begin(strings10), end(strings10), generator);

    vector<string> strings100(100);
    generate(begin(strings100), end(strings100), generator);

    vector<string> strings1000(1000);
    generate(begin(strings1000), end(strings1000), generator);

    vector<string> strings10000(10000);
    generate(begin(strings10000), end(strings10000), generator);

    auto t1 = chrono::system_clock::now();
    for(int i = 0; i<reps; ++i)
    {
        join(sep, strings10);
    }

    auto t2 = chrono::system_clock::now();
    for(int i = 0; i<reps; ++i)
    {
        join(sep, strings100);
    }

    auto t3 = chrono::system_clock::now();
    for(int i = 0; i<reps; ++i)
    {
        join(sep, strings1000);
    }

    auto t4 = chrono::system_clock::now();
    for(int i = 0; i<reps; ++i)
    {
        join(sep, strings10000);
    }

    auto t5 = chrono::system_clock::now();

    auto d1 = chrono::duration_cast<chrono::milliseconds>(t2 - t1);
    auto d2 = chrono::duration_cast<chrono::milliseconds>(t3 - t2);
    auto d3 = chrono::duration_cast<chrono::milliseconds>(t4 - t3);
    auto d4 = chrono::duration_cast<chrono::milliseconds>(t5 - t4);

    cout << "join(10)   : " << d1.count() << endl;
    cout << "join(100)  : " << d2.count() << endl;
    cout << "join(1000) : " << d3.count() << endl;
    cout << "join(10000): " << d4.count() << endl;
}

결과 (밀리 초) :

join(10)   : 2
join(100)  : 10
join(1000) : 91
join(10000): 898

3

어쩌면 당신은 내 "스 트리머"솔루션이 실제로 한 줄로 그것을 좋아할 것입니다.

#include <iostream>
#include <sstream>
using namespace std;

class Streamer // class for one line string generation
{
public:

    Streamer& clear() // clear content
    {
        ss.str(""); // set to empty string
        ss.clear(); // clear error flags
        return *this;
    }

    template <typename T>
    friend Streamer& operator<<(Streamer& streamer,T str); // add to streamer

    string str() // get current string
    { return ss.str();}

private:
    stringstream ss;
};

template <typename T>
Streamer& operator<<(Streamer& streamer,T str)
{ streamer.ss<<str;return streamer;}

Streamer streamer; // make this a global variable


class MyTestClass // just a test class
{
public:
    MyTestClass() : data(0.12345){}
    friend ostream& operator<<(ostream& os,const MyTestClass& myClass);
private:
    double data;
};

ostream& operator<<(ostream& os,const MyTestClass& myClass) // print test class
{ return os<<myClass.data;}


int main()
{
    int i=0;
    string s1=(streamer.clear()<<"foo"<<"bar"<<"test").str();                      // test strings
    string s2=(streamer.clear()<<"i:"<<i++<<" "<<i++<<" "<<i++<<" "<<0.666).str(); // test numbers
    string s3=(streamer.clear()<<"test class:"<<MyTestClass()).str();              // test with test class
    cout<<"s1: '"<<s1<<"'"<<endl;
    cout<<"s2: '"<<s2<<"'"<<endl;
    cout<<"s3: '"<<s3<<"'"<<endl;
}

2

한 줄짜리 솔루션은 다음과 같습니다.

#include <iostream>
#include <string>

int main() {
  std::string s = std::string("Hi") + " there" + " friends";
  std::cout << s << std::endl;

  std::string r = std::string("Magic number: ") + std::to_string(13) + "!";
  std::cout << r << std::endl;

  return 0;
}

조금 추악하지만 C ++에서 얻는 것처럼 깨끗하다고 ​​생각합니다.

첫 번째 인수를 a로 캐스팅 std::string한 다음 왼쪽 피연산자가 항상 a operator+인지 확인 하기 위해 (왼쪽에서 오른쪽으로) 평가 순서 를 사용합니다 . 이런 식으로 왼쪽의 피연산자와 오른쪽 피연산자를 연결하고 다른 피연산자를 반환합니다.std::stringstd::stringconst char *std::string 하여 효과를 계단식으로 만듭니다.

참고 : 오른쪽 피연산자 const char *에는 std::string, 및char .

매직 넘버가 13인지 6227020800인지를 결정하는 것은 당신에게 달려 있습니다.


아, 당신은 @Apollys를 잊어 버립니다. 보편적 인 마법의 숫자는 42입니다. : D
Mr.Zeus


1

사용하려는 경우 사용자 정의 문자열 리터럴 을 사용하고 객체와 다른 객체에 대한 더하기 연산자를 오버로드하는 두 개의 함수 템플릿을 정의 c++11할 수 있습니다 . 유일한 함정은의 더하기 연산자를 오버로드 하지 않는 것 입니다 . 그렇지 않으면 컴파일러는 사용할 연산자를 모릅니다. 템플릿 을 사용하여이 작업을 수행 할 수 있습니다.std::stringstd::stringstd::enable_iftype_traits . 그 후에 문자열은 Java 또는 C #에서와 같이 동작합니다. 자세한 내용은 예제 구현을 참조하십시오.

메인 코드

#include <iostream>
#include "c_sharp_strings.hpp"

using namespace std;

int main()
{
    int i = 0;
    float f = 0.4;
    double d = 1.3e-2;
    string s;
    s += "Hello world, "_ + "nice to see you. "_ + i
            + " "_ + 47 + " "_ + f + ',' + d;
    cout << s << endl;
    return 0;
}

파일 c_sharp_strings.hpp

이 문자열을 갖고 싶은 모든 곳에이 헤더 파일을 포함 시키십시오.

#ifndef C_SHARP_STRING_H_INCLUDED
#define C_SHARP_STRING_H_INCLUDED

#include <type_traits>
#include <string>

inline std::string operator "" _(const char a[], long unsigned int i)
{
    return std::string(a);
}

template<typename T> inline
typename std::enable_if<!std::is_same<std::string, T>::value &&
                        !std::is_same<char, T>::value &&
                        !std::is_same<const char*, T>::value, std::string>::type
operator+ (std::string s, T i)
{
    return s + std::to_string(i);
}

template<typename T> inline
typename std::enable_if<!std::is_same<std::string, T>::value &&
                        !std::is_same<char, T>::value &&
                        !std::is_same<const char*, T>::value, std::string>::type
operator+ (T i, std::string s)
{
    return std::to_string(i) + s;
}

#endif // C_SHARP_STRING_H_INCLUDED

1

이 같은 것이 나를 위해 작동

namespace detail {
    void concat_impl(std::ostream&) { /* do nothing */ }

    template<typename T, typename ...Args>
    void concat_impl(std::ostream& os, const T& t, Args&&... args)
    {
        os << t;
        concat_impl(os, std::forward<Args>(args)...);
    }
} /* namespace detail */

template<typename ...Args>
std::string concat(Args&&... args)
{
    std::ostringstream os;
    detail::concat_impl(os, std::forward<Args>(args)...);
    return os.str();
}
// ...
std::string s{"Hello World, "};
s = concat(s, myInt, niceToSeeYouString, myChar, myFoo);

1

위의 솔루션을 기반으로 프로젝트를 쉽게 만들 수 있도록 var_string 클래스를 만들었습니다. 예 :

var_string x("abc %d %s", 123, "def");
std::string y = (std::string)x;
const char *z = x.c_str();

수업 자체 :

#include <stdlib.h>
#include <stdarg.h>

class var_string
{
public:
    var_string(const char *cmd, ...)
    {
        va_list args;
        va_start(args, cmd);
        vsnprintf(buffer, sizeof(buffer) - 1, cmd, args);
    }

    ~var_string() {}

    operator std::string()
    {
        return std::string(buffer);
    }

    operator char*()
    {
        return buffer;
    }

    const char *c_str()
    {
        return buffer;
    }

    int system()
    {
        return ::system(buffer);
    }
private:
    char buffer[4096];
};

C ++에서 더 좋은 것이 있는지 궁금합니다.


1

c11에서 :

void printMessage(std::string&& message) {
    std::cout << message << std::endl;
    return message;
}

이를 통해 다음과 같이 함수 호출을 작성할 수 있습니다.

printMessage("message number : " + std::to_string(id));

인쇄합니다 : 메시지 번호 : 10


0

문자열 클래스를 "확장"하고 원하는 연산자를 선택할 수도 있습니다 (<<, &, | 등 ...).

다음은 스트림과 충돌이 없음을 보여주기 위해 operator <<를 사용하는 코드입니다.

참고 : s1.reserve (30)의 주석 처리를 제거하면 3 개의 new () 연산자 요청 만 있습니다 (s1의 경우 1, s2의 경우 1, 예약의 경우 1; 불행히도 생성자 시간에 예약 할 수 없음). 예비가 없으면 s1은 증가함에 따라 더 많은 메모리를 요청해야하므로 컴파일러 구현 증가 요인에 따라 다릅니다 (이 예제에서는 광산이 1.5, 5 new () 호출 인 것 같습니다)

namespace perso {
class string:public std::string {
public:
    string(): std::string(){}

    template<typename T>
    string(const T v): std::string(v) {}

    template<typename T>
    string& operator<<(const T s){
        *this+=s;
        return *this;
    }
};
}

using namespace std;

int main()
{
    using string = perso::string;
    string s1, s2="she";
    //s1.reserve(30);
    s1 << "no " << "sunshine when " << s2 << '\'' << 's' << " gone";
    cout << "Aint't "<< s1 << " ..." <<  endl;

    return 0;
}

0

람다 함수를 사용하는 간단한 선행 작업 매크로가있는 문자열 스트림은 멋지게 보입니다.

#include <sstream>
#define make_string(args) []{std::stringstream ss; ss << args; return ss;}() 

그리고

auto str = make_string("hello" << " there" << 10 << '$');

-1

이것은 나를 위해 작동합니다 :

#include <iostream>

using namespace std;

#define CONCAT2(a,b)     string(a)+string(b)
#define CONCAT3(a,b,c)   string(a)+string(b)+string(c)
#define CONCAT4(a,b,c,d) string(a)+string(b)+string(c)+string(d)

#define HOMEDIR "c:\\example"

int main()
{

    const char* filename = "myfile";

    string path = CONCAT4(HOMEDIR,"\\",filename,".txt");

    cout << path;
    return 0;
}

산출:

c:\example\myfile.txt

12
새끼 고양이는 코드 가드 나 상수보다 복잡한 것을 위해 매크로를 사용할 때마다 울음 : P
Rui Marques

1
불행한 새끼 고양이 옆 : 각 인수마다 필요하지 않은 문자열 객체가 생성됩니다.
SebastianK

2
매크로를 사용하는 것은 확실히 나쁜 해결책이므로 downvoted
dhaumann

이것은 C조차도 나를 공포에 빠뜨릴 것이지만 C ++에서는 악마입니다. @ RuiMarques : 어떤 상황에서 상수보다 매크로가 a보다 좋 const거나 (제로 저장이 필요한 경우) 그렇지 enum않을까요?
underscore_d

@underscore_d 흥미로운 질문이지만 대답이 없습니다. 아마도 대답은 없을 것입니다.
Rui Marques

-1

+ =를 피하려고 했습니까? 대신 var = var + ...를 사용하십시오.

#include <iostream.h> // for string

string myName = "";
int _age = 30;
myName = myName + "Vincent" + "Thorpe" + 30 + " " + 2019;

나는 C ++ 볼랜드 빌더 6을 사용하며 나에게 잘 작동합니다. 이 헤더를 포함하는 것을 잊지 #include <iostream.h> // string #include <system.hpp> // ansiString
마십시오

+ =이 경우 과부하되지 않으며, 당신은 숫자가 아니라 CONCATENATE 문자열을 추가했다 생각하는 것
빈센트 소프
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.