كيف يمكنني لسلسلة متعددة C++ السلاسل على السطر ؟
-
20-08-2019 - |
سؤال
C# يحتوي بناء جملة ميزة حيث يمكنك ضم العديد من أنواع البيانات معا في 1 خط.
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.";
رمز أعلاه ينتج خطأ.
المحلول
#include <sstream>
#include <string>
std::stringstream ss;
ss << "Hello, world, " << myInt << niceToSeeYouString;
std::string s = ss.str();
ونلقي نظرة على هذا المعلم من هذه المادة أسبوع من عشب سوتر: ومنسقات سلسلة من مزرعة مانور
نصائح أخرى
في 5 سنوات وقد ذكر أحد .append
؟
#include <string>
std::string s;
s.append("Hello world, ");
s.append("nice to see you, ");
s.append("or not.");
s += "Hello world, " + "nice to see you, " + "or not.";
وهذه الحرفية الطابع مجموعة ليست C ++ الأمراض المنقولة جنسيا :: سلاسل - أنت نيد لتحويلها:
s += string("Hello world, ") + string("nice to see you, ") + string("or not.");
لتحويل [إينتس] (أو أي نوع آخر للبث) يمكنك استخدام دفعة lexical_cast أو توفير وظيفة الخاصة بك:
template <typename T>
string Str( const T & t ) {
ostringstream os;
os << t;
return os.str();
}
ويمكنك الآن يقول أشياء مثل:
string s = "The meaning is " + Str( 42 );
التعليمات البرمجية الخاصة بك كما يمكن كتابة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 "كما يمكن كتابة":هذا يعمل فقط على سلسلة حرفية.سلسلة يتم عن طريق مترجم.
وعن طريق 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";
لتقديم حل أكثر من سطر واحد العش:وظيفة concat
يمكن تنفيذها للحد من "الكلاسيكية" stringstream على أساس حل بيان واحد.لأنه يقوم على variadic قوالب مثالية الشحن.
الاستخدام:
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();
}
ودفعة :: شكل
وأو الأمراض المنقولة جنسيا :: stringstream
std::stringstream msg;
msg << "Hello world, " << myInt << niceToSeeYouString;
msg.str(); // returns std::string object
على المشكلة الفعلية وكان أن وصل سلسلة حرفية مع +
فشل في C++:
string s;
s += "Hello world, " + "nice to see you, " + "or not.";
رمز أعلاه ينتج خطأ.
في 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)
أو إذا كنت تصر في استخدام +
عن سلسلة حرفية (كما اقترح من قبل 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.";
auto s = string("one").append("two").append("three")
{معاهدة المواد الانشطارية} مكتبة الذي يمكن القيام به:
auto s = fmt::format("{}{}{}", "Hello world, ", myInt, niceToSeeYouString);
ويقترح مجموعة فرعية من المكتبة لتوحيد كما P0645 تنسيق النص ، وإذا قبلت ، ما سبق سوف تصبح:
auto s = std::format("{}{}{}", "Hello world, ", myInt, niceToSeeYouString);
<القوي> تنويه : ل. أنا مؤلف {معاهدة المواد الانشطارية} مكتبة
وعملتم لتحديد المشغل + () لكل نوع البيانات التي تريد أن concenate إلى سلسلة، ولكن منذ مشغل << غير محددة لمعظم أنواع، يجب عليك استخدام الأمراض المنقولة جنسيا :: stringstream.
واللعنة، وفاز بنسبة 50 ثواني ...
إذا الكتابة خارج +=
، يبدو تقريبا نفس C #
string s("Some initial data. "); int i = 5;
s = s + "Hello world, " + "nice to see you, " + to_string(i) + "\n";
وكما قال آخرون، فإن المشكلة الرئيسية مع رمز OP هي أن +
المشغل لا سلسلة const char *
. يعمل مع std::string
، وإن كان.
وهنا حل آخر يستخدم C ++ 11 lambdas و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
وربما كنت أحب بلدي "الملون" حل لتفعل ذلك حقا في سطر واحد:
#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;
}
ويمكنك استخدام هذا رأس هذا الصدد: https://github.com/theypsilon/concat
using namespace concat;
assert(concat(1,2,3,4,5) == "12345");
وتحت غطاء محرك السيارة سوف تكون باستخدام الأمراض المنقولة جنسيا :: ostringstream.
إذا كنت على استعداد لاستخدام c++11
يمكنك استخدام سلسلة حرفية المعرفة أ > وتحديد اثنين من القوالب وظيفة أن تفرط في المشغل بالإضافة لكائن std::string
وأي كائن آخر. في شرك الوحيد هو عدم التحميل الزائد مشغلي زائد std::string
، وإلا فإن المترجم لا يعرف أي مشغل للاستخدام. يمكنك القيام بذلك عن طريق استخدام قالب std::enable_if
من <لأ href = "HTTP: //en.cppreference.com/w/cpp/header/type_traits "يختلط =" نوفولو "> type_traits
. بعد أن سلاسل تتصرف تماما مثل في جاوة أو 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
ويمكنك أيضا "تمديد" الطبقة سلسلة واختيار المشغل كنت تفضل (<<، و، |، الخ ...)
وهنا هي المشغل التعليمات البرمجية باستخدام << لإظهار وجود تعارض مع تيارات
ملاحظة: إذا كنت s1.reserve غير تعليق (30)، وهناك فقط 3 الجديدة طلبات المشغل () (1 لS1، S2 1 ل(1)، لاحتياطي، لا يمكنك حجز في وقت المنشئ للأسف). دون تحفظ، s1 ولديها لطلب المزيد من الذاكرة لأنها تنمو، لذلك يعتمد على تنفيذ المترجم الخاص بك ينمو عامل (الألغام يبدو أن 1،5، 5 جديدة () ويدعو في هذا المثال)
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;
}
وشيء من هذا القبيل يعمل بالنسبة لي
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);
وبناء على الحلول المذكورة أعلاه ولقد تقدمت 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 ++؟
في C11:
void printMessage(std::string&& message) {
std::cout << message << std::endl;
return message;
}
وهذا يسمح لك لخلق استدعاء دالة مثل هذا:
printMessage("message number : " + std::to_string(id));
وستطبع: رقم الرسالة: 10
هنا هو واحد بطانة الحل:
#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++.
نحن الصب الحجة الأولى إلى std::string
ثم استخدام (من اليسار إلى اليمين) تقييم النظام من operator+
لضمان اليسار المعامل دائما std::string
.في هذه الطريقة, نحن لسلسلة std::string
على اليسار مع const char *
المعامل على حق عودة أخرى std::string
, المتتالية تأثير.
ملاحظة:وهناك عدد قليل من الخيارات للحصول على حق المعامل ، بما في ذلك const char *
, std::string
, ، char
.
الأمر متروك لكم أن تقرر ما إذا كان السحر هو رقم 13 أو 6227020800.
وStringstream مع ماكرو preproccessor بسيط باستخدام وظيفة امدا يبدو لطيف:
#include <sstream>
#define make_string(args) []{std::stringstream ss; ss << args; return ss;}()
ثم
auto str = make_string("hello" << " there" << 10 << '$');
وهذا يعمل بالنسبة لي:
#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
هل حاولت تجنب + =؟ بدلا من استخدام فار فار = + ... لأنها عملت لي.
#include <iostream.h> // for string
string myName = "";
int _age = 30;
myName = myName + "Vincent" + "Thorpe" + 30 + " " + 2019;