एक std :: string में एक चार को कैसे जोड़ा जाए?

Question

निम्न त्रुटि के साथ विफल हो जाता है prog.cpp:5:13: error: invalid conversion from ‘char’ to ‘const char*’

int main()
{
  char d = 'd';
  std::string y("Hello worl");
  y.append(d); // Line 5 - this fails
  std::cout << y;
  return 0;
}

मैंने भी कोशिश की, निम्नलिखित, जो संकलित करता है, लेकिन रनटाइम पर बेतरतीब ढंग से व्यवहार करता है:

int main()
{
  char d[1] = { 'd' };
  std::string y("Hello worl");
  y.append(d);
  std::cout << y;
  return 0;
}

इस गूंगे प्रश्न के लिए क्षमा करें, लेकिन मैंने Google के चारों ओर खोज की है, जो मैं देख सकता था, वह है "char array to char ptr", "char ptr to char array", आदि।

Comments

एक संकलक त्रुटि हाँ..मैं भूल गया कि त्रुटि क्या है, लेकिन यह उचित है।

— drowneath

आपके पास नीचे बेहतर उत्तर हैं, लेकिन आप इस चर d [2] = {'d', 0} की तरह काम करते हुए दूसरा उदाहरण बना सकते हैं; या सिर्फ चार डी [2] = "डी"; मूल रूप से, आपको अपने सी-स्टाइल स्ट्रिंग को समाप्त करने के लिए एक 0 की आवश्यकता है जिसे आप पास करना चाहते हैं

— sbk

यहाँ अच्छा दस्तावेज: sgi.com/tech/stl/basic_string.html

— मार्टिन

Answer 1

y += d;

मैं +=नामित कार्यों के बजाय ऑपरेटर का उपयोग करूंगा ।

Comments

आप पुश_बैक से बेहतर + क्यों मानते हैं? क्या यह सिर्फ कम टाइपिंग है या आपके पास कोई और कारण है?

— ग्लेन

यह कम टाइपिंग है। में gcc, basic_string::operator+=सिर्फ एक कॉल है push_back।

— एडफी

यह स्ट्रिंग्स के लिए अधिक प्राकृतिक आईएमओ है। push_back कंटेनर फ़ंक्शन है, और एक स्ट्रिंग STL में एक विशेष है :)

— आरा

आइए उस प्रश्न को चारों ओर मोड़ें: आप पुश_बैक को + = से बेहतर क्यों मानते हैं? मेरी राय में, + = स्पष्ट और संक्षिप्त है।

— जेसपर

आप इससे सावधान रहना चाहते हैं क्योंकि अगर आप इसकी आदत में शामिल हो जाते हैं, तो यह ठीक होगा, अगर इसके बजाय yयह ठीक है । यह सूचक y के लिए वर्ण जोड़ देगा । char*std::stringd

— ज़ेन लिंक्स

Answer 2

उपयोग करें push_back():

std::string y("Hello worl");
y.push_back('d')
std::cout << y;

Answer 3

एपीडी पद्धति का उपयोग करके std :: string var में एक char जोड़ने के लिए, आपको इस अधिभार का उपयोग करने की आवश्यकता है:

std::string::append(size_type _Count, char _Ch)

संपादित करें: आप सही हैं मैंने size_type पैरामीटर को गलत समझा, संदर्भ सहायता में प्रदर्शित किया। यह जोड़ने के लिए वर्णों की संख्या है। तो सही कॉल है

s.append(1, d);

नहीं

s.append(sizeof(char), d);

या सबसे सरल तरीका:

s += d;

Comments

मुझे लगता है कि आकार का उपयोग करना शब्दार्थ रूप से सही नहीं है (भले ही यह आकार के रूप में काम करने के लिए होता है (चार) हमेशा एक होता है)। यदि आप एक ही चरित्र की अधिक प्रतियों को जोड़ना चाहते हैं तो एपेंड विधि स्वाभाविक रूप से अधिक उपयोगी है !!!!!!!!!!

— चाचा

आप sizeof(char)इसके बजाय क्यों उपयोग कर रहे हैं 1? आप वास्तव में एक पुनरावृत्ति को जोड़ना चाहते हैं d, तो बस यही कहेंगे। sizeofयहां उपयोग करना भ्रामक है क्योंकि यह बताता है कि किसी को appendउपयोग किए गए डेटा प्रकार के बाइट का आकार बताना होगा (जो कि मामला नहीं है)।

— फर्डिनेंड बेयर

जैसा कि अंकलबेंस ने कहा, कई बार एक ही चरित्र को जोड़ते समय एपेंड विधि अधिक उपयोगी होती है।

— पैट्रिस बर्नसोला

Answer 4

उल्लिखित अन्य लोगों के अलावा, स्ट्रिंग निर्माताओं में से एक चार और उस चार के लिए दोहराव की संख्या लेता है। तो आप इसका उपयोग कर सकते हैं कि एक ही चार को जोड़ सकते हैं।

std::string s = "hell";
s += std::string(1, 'o');

Answer 5

मैं एक बड़े लूप में चलाकर कई प्रस्तावों का परीक्षण करता हूं। मैंने संकलक के रूप में Microsoft दृश्य स्टूडियो 2015 का उपयोग किया और मेरा प्रोसेसर एक i7, 8Hz, 2GHz है।

    long start = clock();
    int a = 0;
    //100000000
    std::string ret;
    for (int i = 0; i < 60000000; i++)
    {
        ret.append(1, ' ');
        //ret += ' ';
        //ret.push_back(' ');
        //ret.insert(ret.end(), 1, ' ');
        //ret.resize(ret.size() + 1, ' ');
    }
    long stop = clock();
    long test = stop - start;
    return 0;

इस परीक्षण के अनुसार, परिणाम हैं:

     operation             time(ms)            note
------------------------------------------------------------------------
append                     66015
+=                         67328      1.02 time slower than 'append'
resize                     83867      1.27 time slower than 'append'
push_back & insert         90000      more than 1.36 time slower than 'append'

निष्कर्ष

+= अधिक समझ में आता है, लेकिन यदि आप गति के बारे में मन रखते हैं, तो एपेंड का उपयोग करें

Comments

इस तरह के उत्तर को सार्थक बनाने के लिए, आपको कम से कम यह बताना चाहिए कि आप किस संकलक का उपयोग कर रहे हैं, क्योंकि ऐसी चीजें बहुत भिन्न हो सकती हैं। अपने प्रोसेसर के बारे में बताना भी बहुत अच्छा हो सकता है, इसके वास्तविक प्रभाव पर मोटा अनुमान लगाने के लिए।

— अकलतरा

मैंने विज़ुअल स्टूडियो 2015 का इस्तेमाल किया। मैं कुछ अन्य टेस्ट करने के लिए gcc की तलाश करूंगा। मेरा प्रोसेसर i7, 8 हार्ट, 2.20 Ghz है .... लेकिन जो भी मेरा प्रोसेसर है, उसका std :: string कार्यान्वयन पर कोई प्रभाव नहीं पड़ेगा ... सिवाय इसके कि इनमें से कुछ विधियां बहुप्रचलित हैं और कुछ माताएं नहीं।

— ह्यूगो जेवेटेल

कभी-कभी इसका प्रभाव पड़ता है, खासकर यदि आप मिलीसेकंड में समय दिखा रहे हैं। इसके बजाय आप सबसे तेज़ विधि के सापेक्ष प्रतिशत में दिखा सकते हैं (इसलिए वास्तविक प्रोसेसर गति अप्रासंगिक है) उस डेटा को टिप्पणी से अपने उत्तर में स्थानांतरित करें, यह सिर्फ सामान्य StackExchange etiquette है। अन्यथा अच्छा जवाब।

— 15

Answer 6

+ = ऑपरेटर लिंक पाठ , परिशिष्ट () विधि लिंक पाठ , या पुश_बैक () विधि लिंक पाठ आज़माएं

इस पोस्ट के लिंक में संबंधित एपीआई का उपयोग करने के उदाहरण भी हैं।

Answer 7

के साथ समस्या:

std::string y("Hello worl");
y.push_back('d')
std::cout << y;

यह है कि आपके पास एक वर्ण का नाम का उपयोग करने के विपरीत 'd' होना चाहिए, जैसे char d = 'd'; या मैं गलत हूँ?

Comments

मैंने बस कोशिश की और यह ठीक काम कर गया। मेरे पास है char c = 'd'और मैं y.push_back(c)बिना मुद्दे के कर सकता हूं । इसलिए इसमें कोई समस्या नहीं है std::string::push_back()(सिवाय इसके कि यह अधिक लंबा है +=)।

— फ्रैंकलिन यू

Answer 8

int main()
{
  char d = 'd';
  std::string y("Hello worl");

  y += d;
  y.push_back(d);
  y.append(1, d); //appending the character 1 time
  y.insert(y.end(), 1, d); //appending the character 1 time
  y.resize(y.size()+1, d); //appending the character 1 time
  y += std::string(1, d); //appending the character 1 time
}

ध्यान दें कि इन सभी उदाहरणों में आप सीधे एक चरित्र शाब्दिक का उपयोग कर सकते थे y += 'd';:।

आपके दूसरे उदाहरण ने लगभग असंबंधित कारणों से काम किया होगा। char d[1] = { 'd'};काम नहीं किया, लेकिन char d[2] = { 'd'};(ध्यान दें कि सरणी का आकार दो है) लगभग उसी तरह काम किया गया होगा const char* d = "d";, और एक स्ट्रिंग शाब्दिक जोड़ा जा सकता है y.append(d);:।

Answer 9

सूचक y.append (* d) के रूप में d का उपयोग करने का प्रयास करें

Comments

यह खतरनाक है क्योंकि एक एकल charस्ट्रिंग नहीं है और कोई शून्य-टर्मिनेटर नहीं है। ऐसा करने से अपरिभाषित व्यवहार होता है।

— साइमन क्रैमर

यह सिर्फ गलत है। *dडी-रेफरेंस पॉइंटर का मतलब है dजो एक सिंटैक्स त्रुटि है क्योंकि dपॉइंटर नहीं है।

— फ्रैंकलिन यू

Answer 10

str.append(10u,'d'); //appends character d 10 times

ध्यान दें कि मैंने चरित्र को जोड़ने के लिए 10u और न कि 10 बार लिखा है ; 10 को जो भी संख्या से प्रतिस्थापित करें।

Answer 11

मुझे एक सरल रास्ता मिला ... मुझे charएक स्ट्रिंग से निपटने की ज़रूरत थी जो मक्खी पर बनाई जा रही थी। मुझे इसकी आवश्यकता थी char list;क्योंकि मैं एक switch()बयान में उपयोगकर्ता को एक विकल्प दे रहा था और उस विकल्प का उपयोग कर रहा था ।

मैंने बस एक std::string Slist;और जोड़ा है और चरित्र के बराबर नया स्ट्रिंग सेट किया है, "सूची" - ए, बी, सी या जो भी अंतिम उपयोगकर्ता पसंद करता है वह इस तरह है:

char list;
std::string cmd, state[], Slist;
Slist = list; //set this string to the chosen char;
cmd = Slist + state[x] + "whatever";
system(cmd.c_str());

जटिलता शांत हो सकती है लेकिन सरलता कूलर है। IMHO

Answer 12

डालने का विकल्प भी जोड़ रहा है, जैसा कि अभी तक उल्लेख नहीं किया गया है।

std::string str("Hello World");
char ch;

str.push_back(ch);  //ch is the character to be added
OR
str.append(sizeof(ch),ch);
OR
str.insert(str.length(),sizeof(ch),ch) //not mentioned above

Answer 13

यदि आप push_back का उपयोग कर रहे हैं, तो स्ट्रिंग निर्माता के लिए कोई कॉल नहीं है। अन्यथा यह कास्टिंग के माध्यम से एक स्ट्रिंग ऑब्जेक्ट बनाएगा, फिर वह इस स्ट्रिंग में चरित्र को अन्य स्ट्रिंग में जोड़ देगा। एक छोटे चरित्र के लिए बहुत परेशानी;)

Comments

ऑपरेटर + = (चार सी); तार के लिए अतिभारित है। वास्तव में, स्ट्रिंग निर्माता एक चरित्र को स्वीकार नहीं करता है, ब्रायन उत्तर देखें;)

— आरा '24