I have a text file that I want to read. I want to know if one of the lines contains `[` so I tried :

    if(array[i] == &quot;[&quot;)

But this isn&#39;t working.

How can I check if a string contains a certain character?

How to check if a string contains a char?

I am reading through Anthony Williams&#39; &quot;C++ Concurrency in Action&quot; and in Chapter 5, which talks about the new multithreading-aware memory model and atomic operations, and he states:

&gt; In order to use `std::atomic&lt;UDT&gt;` for some  user-defined `UDT`, this type must have a _trivial_ copy assignment operator.

As I understand it, this means that we can use `std::atomic&lt;UDT&gt;` if the following returns true:

    std::is_trivially_copyable&lt;UDT&gt;::value

By this logic, we shouldn&#39;t be able to use `std::string` as a template argument for `std::atomic` and have it work correctly.

However, the following code compiles and runs with expected output:

    #include &lt;atomic&gt;
    #include &lt;thread&gt;
    #include &lt;iostream&gt;
    #include &lt;string&gt;

    int main()
    {
    	std::atomic&lt;std::string&gt; atomicString;
    
    	atomicString.store( &quot;TestString1&quot; );
    
    	std::cout &lt;&lt; atomicString.load() &lt;&lt; std::endl;
    
    	atomicString.store( &quot;TestString2&quot; );
    
    	std::cout &lt;&lt; atomicString.load() &lt;&lt; std::endl;
    
    	return 0;
    }

Is this a case of undefined behaviour which just happens to behave as expected?

Thanks in advance!

Does std::atomic&lt;std::string&gt; work appropriately?

I have some numbers of different length (like 1, 999, 76492, so on) and I want to convert them all to strings with a common length (for example, if the length is 6, then those strings will be: &#39;000001&#39;, &#39;000999&#39;, &#39;076492&#39;). 

In other words, I need to add correct amount of leading zeros to the number.

    int n = 999;
    string str = some_function(n,6);
    //str = &#39;000999&#39;

Is there a function like this in C++?



Convert a number to a string with specified length in C++

*Using C++11, Ubuntu 14.04, GCC default toolchain*.

This code fails:

    constexpr std::string constString = &quot;constString&quot;;

&gt; error: the type ‘const string {aka const std::basic_string&lt;char&gt;}’ of
&gt; constexpr variable ‘constString’ is not literal... because...
&gt; ‘std::basic_string&lt;char&gt;’ has a non-trivial destructor

Is it possible to use `std::string` in a`constexpr`? (apparently not...) If so, how? Is there an alternative way to use a character string in a `constexpr`?


Is it possible to use std::string in a constexpr?

I&#39;m currently using the following code to right-trim all the `std::strings` in my programs:

    std::string s;
    s.erase(s.find_last_not_of(&quot; \n\r\t&quot;)+1);

It works fine, but I wonder if there are some end-cases where it might fail?

Of course, answers with elegant alternatives and also left-trim solution are welcome.

How to trim a std::string?

    int i = 4;
    string text = &quot;Player &quot;;
    cout &lt;&lt; (text + i);

I&#39;d like it to print `Player 4`.

The above is obviously wrong but it shows what I&#39;m trying to do here. Is there an easy way to do this or do I have to start adding new includes?

How do you append an int to a string in C++?

I thought this would be really simple, but it&#39;s presenting some difficulties. If I have

    std::string name = &quot;John&quot;;
    int age = 21;

How do I combine them to get a single string `&quot;John21&quot;`?




How to concatenate a std::string and an int

I was wondering if there was an alternative to `itoa()` for converting an integer to a string because when I run it in visual Studio I get warnings, and when I try to build my program under Linux, I get a compilation error.


Alternative to itoa() for converting integer to string C++?

It had been my understanding that copy-on-write is not a viable way to implement a conforming `std::string` in C++11, but when it came up in discussion recently I found myself unable to directly support that statement.

Am I correct that C++11 does not admit COW based implementations of `std::string`?

If so, is this restriction explicitly stated somewhere in the new standard (where)?

Or is this restriction implied, in the sense that it is the combined effect of the new requirements on `std::string` that precludes a COW based implementation of `std::string`. In this case, I&#39;d be interested in a chapter and verse style derivation of &#39;C++11 effectively prohibits COW based `std::string` implementations&#39;.

Legality of COW std::string implementation in C++11

How should I get the number of characters in a string in C++?

How to get the number of characters in a std::string?

What is the effective way to replace all occurrences of a character with another character in `std::string`?

How to replace all occurrences of a character in string?

What does the phrase `std::string::npos` mean in the following snippet of code?

    found = str.find(str2);

    if (found != std::string::npos)
        std::cout &lt;&lt; &quot;first &#39;needle&#39; found at: &quot; &lt;&lt; int(found) &lt;&lt; std::endl;


What does string::npos mean in this code?

I have to format [`std::string`](http://en.cppreference.com/w/cpp/string/basic_string) with [`sprintf`](http://en.cppreference.com/w/cpp/io/c/fprintf) and send it into file stream. How can I do this?

std::string formatting like sprintf

Hi I am trying to convert a standard `std::string` into an `NSString` but I&#39;m not having much luck.

I can convert successfully from an `NSString` to a `std::string` with the following code
    
    NSString *realm = @&quot;Hollywood&quot;;
    std::string REALM = [realm cStringUsingEncoding:[NSString defaultCStringEncoding]];

However I get a compile time error when I try the following
     
    NSString *errorMessage = [NSString stringWithCString:REALM encoding:[NSString defaultCStringEncoding]];

The error I get is 

    Cannot convert &#39;std::string&#39; to &#39;const char*&#39; in argument passing

Am I missing something here?

Thanks in advance.


How to convert std::string to NSString?

I&#39;m looking for the most elegant way to implode a vector of strings into a string. Below is the solution I&#39;m using now:

    static std::string&amp; implode(const std::vector&lt;std::string&gt;&amp; elems, char delim, std::string&amp; s)
    {
        for (std::vector&lt;std::string&gt;::const_iterator ii = elems.begin(); ii != elems.end(); ++ii)
        {
            s += (*ii);
            if ( ii + 1 != elems.end() ) {
                s += delim;
            }
        }

        return s;
    }

    static std::string implode(const std::vector&lt;std::string&gt;&amp; elems, char delim)
    {
        std::string s;
        return implode(elems, delim, s);
    }

Is there any others out there?


How to implode a vector of strings into a string (the elegant way)

If I want to construct a std::string with a line like:

    std::string my_string(&quot;a\0b&quot;);

Where i want to have three characters in the resulting string (a, null, b), I only get one.  What is the proper syntax?

How do you construct a std::string with an embedded null?

Using http://en.cppreference.com/w/cpp/string/basic_string_view as a reference, I see no way to do this more elegantly:

    std::string s = &quot;hello world!&quot;;
    std::string_view v = s;
    v = v.substr(6, 5); // &quot;world&quot;

Worse, the naive approach is a pitfall and leaves `v` a dangling reference to a temporary:

    std::string s = &quot;hello world!&quot;;
    std::string_view v(s.substr(6, 5)); // OOPS!

I _seem to remember_ something like there might be an addition to the standard library to return a substring as a view:

    auto v(s.substr_view(6, 5));

I can think of the following workarounds:

    std::string_view(s).substr(6, 5);
    std::string_view(s.data()+6, 5);
    // or even &quot;worse&quot;:
    std::string_view(s).remove_prefix(6).remove_suffix(1);

Frankly, I don&#39;t think any of these are very nice. Right now the best thing I can think of is using aliases to simply make things less verbose.

    using sv = std::string_view;
    sv(s).substr(6, 5);

How to efficiently get a `string_view` for a substring of `std::string`

I notice that in my copy of the SGI STL reference, there is a page about Character Traits but I can&#39;t see how these are used? Do they replace the string.h functions? They don&#39;t seem to be used by `std::string`, e.g. the `length()` method on `std::string` doesn&#39;t make use of the Character Traits `length()` method. Why do Character Traits exist and are they ever used in practice?

What is the point of STL Character Traits?

When should I use `std::string` and when should I use `char*` to manage arrays of `char`s in C++?

It seems you should use `char*` if performance(speed) is crucial and you&#39;re willing to accept some of a risky business because of the memory management.

Are there other scenarios to consider?

char* vs std::string in c++

`CString` is quite handy, while `std::string` is more compatible with STL container. I am using `hash_map`. However, `hash_map` does not support `CString`s as keys, so I want to convert the `CString` into a `std::string`.

Writing a `CString` hash function seems to take a lot of time.

    CString -----&gt; std::string

How can I do this?

    std::string -----&gt; CString:

    inline CString toCString(std::string const&amp; str)
    {
        return CString(str.c_str()); 
    }

Am I right?

----------

**EDIT:**

Here are more questions:

How can I convert from `wstring` to `CString` and vice versa?

    // wstring -&gt; CString
    std::wstring src;
    CString result(src.c_str());
    
    // CString -&gt; wstring
    CString src;
    std::wstring des(src.GetString());

Is there any problem with this?

Additionally, how can I convert from `std::wstring` to `std::string` and vice versa?


How do you convert CString and std::string std::wstring to each other?

I know it is a common issue, but looking for references and other material I don&#39;t find a clear answer to this question.

Consider the following code:

    #include &lt;string&gt;
    
    // ...
    // in a method
    std::string a = &quot;Hello &quot;;
    std::string b = &quot;World&quot;;
    std::string c = a + b;

The compiler tells me it cannot find an overloaded operator for `char[dim]`.

Does it mean that in the string there is not a + operator?

But in several examples there is a situation like this one. If this is not the correct way to concat more strings, what is the best way?

Concatenating strings doesn&#39;t work as expected

At the top of my file I have

    #define AGE &quot;42&quot;

Later in the file I use ID multiple times including some lines that look like

    std::string name = &quot;Obama&quot;;
    std::string str = &quot;Hello &quot; + name + &quot; you are &quot; + AGE + &quot; years old!&quot;;
    str += &quot;Do you feel &quot; + AGE + &quot; years old?&quot;;

I get the error:

&gt; &quot;error: invalid operands of types ‘const char [35]’ and ‘const char [2]’ to binary ‘operator+’&quot;

on line 3. I did some research and found it was because of how C++ was treating the different strings and was able to fix it by changing &quot;AGE&quot; to &quot;string(AGE).&quot; However, I accidentally missed one of the instances until today and was wondering why the compiler wasn&#39;t complaining even though I still had an instance where it was just &quot;AGE&quot;.

Through some trial and error I found that I only need `string(AGE)` on lines where I don&#39;t concatenate another string that was created in the function body.

My questions is &quot;what is going on in the background that C++ doesn&#39;t like concatenating a string with a string put there by the preprocessor unless you are also concatenating string that you defined in the function.&quot;



Error: invalid operands of types ‘const char [35]’ and ‘const char [2]’ to binary ‘operator+’

I need to compare strings  to decide whether they represent the same thing.  This relates to case titles entered by humans where abbreviations and other small details may differ.  For example, consider the following two titles:

    std::string first = &quot;Henry C. Harper v. The Law Offices of Huey &amp; Luey, LLP&quot;;

As opposed to:

    std::string second = &quot;Harper v. The Law Offices of Huey &amp; Luey, LLP&quot;;

A human can quickly gauge that these are most likely one and the same.  The current approach I have taken is to normalize the strings by lowercasing all letters and removing all punctuation and spaces giving:

    std::string firstNormalized = &quot;henrycharpervthelawofficesofhueylueyllp&quot;;

And:

    std::string secondNormalized = &quot;harpervthelawofficesofhueylueyllp&quot;;

Comparing in this case, one is a sub-sequence of the other, but you can imagine other more complex variations where that does not necessarily occur, yet they have significant sub-sequences in common.  There could also be occasional human entry errors such as transposed letters and spelling errors.

Perhaps some kind of character diff program could help?  I&#39;ve seen good line diff programs for comparing differences in code to be checked in, is there something like that on a character basis, maybe in boost?  If you could count the number of consecutive characters in common and take the ratio to the characters unshared, perhaps that would be a good heuristic?

In the end, I need a Boolean decision as to whether to consider them the same or not.  It doesn&#39;t have to be perfect, but it should ideally rarely be wrong.

What algorithm can I use that will give me some kind of quantification as to how similar the two strings are to each other which I can then convert into a yes/no answer by way of some heuristic?

What are some algorithms for comparing how similar two strings are?

Problem: I have an integer; this integer needs to be converted to a stl::string type. 

In the past, I&#39;ve used `stringstream` to do a conversion, and that&#39;s just kind of cumbersome. I know the C way is to do a `sprintf`, but I&#39;d much rather do a C++ method that is typesafe(er).

Is there a better way to do this? 

Here is the stringstream approach I have used in the past:

    std::string intToString(int i)
    {
    	std::stringstream ss;
    	std::string s;
    	ss &lt;&lt; i;
    	s = ss.str();
    	
    	return s;
    }

Of course, this could be rewritten as so:

    template&lt;class T&gt;
    std::string t_to_string(T i)
    {
    	std::stringstream ss;
    	std::string s;
    	ss &lt;&lt; i;
    	s = ss.str();
    	
    	return s;
    }

However, I have the notion that this is a fairly &#39;heavy-weight&#39; implementation.

Zan noted that the invocation is pretty nice, however:

    std::string s = t_to_string(my_integer);


At any rate, a nicer way would be... nice. 

&gt; ###Related:
[Alternative to itoa() for converting integer to string C++?](https://stackoverflow.com/questions/228005/alternative-to-itoa-for-converting-integer-to-string-c)  

c++ integer-&gt;std::string conversion. Simple function?

I have recently seen a colleague of mine using `std::string` as a buffer:

    std::string receive_data(const Receiver&amp; receiver) {
      std::string buff;
      int size = receiver.size();
      if (size &gt; 0) {
        buff.resize(size);
        const char* dst_ptr = buff.data();
        const char* src_ptr = receiver.data();
        memcpy((char*) dst_ptr, src_ptr, size);
      }
      return buff;
    }

I guess this guy wants to take advantage of auto destruction of the returned string so he needs not worry about freeing of the allocated buffer.

This looks a bit **strange** to me since according to [cplusplus.com][1] the `data()` method returns a `const char*` pointing to a buffer internally managed by the string:

    const char* data() const noexcept;

**Memcpy-ing to a const char pointer**? AFAIK this does no harm as long as we know what we do, but have I missed something? Is this dangerous?

  [1]: http://www.cplusplus.com/reference/string/string/data/

Are there downsides to using std::string as a buffer?

I&#39;m using `std::string` and need to left pad them to a given width.  What is the recommended way to do this in C++?

Sample input:

    123

pad to 10 characters.

Sample output:

           123

*(7 spaces in front of 123)*




Padding stl strings in C++

Is there any method?
My computer is AMD64.

    ::std::string str;
    BOOL loadU(const wchar_t* lpszPathName, int flag = 0);

When I used: 

    loadU(&amp;str);

the VS2005 compiler says:

    Error 7 error C2664:: cannot convert parameter 1 from &#39;std::string *__w64 &#39; to &#39;const wchar_t *&#39;

How can I do it?

I want to convert std::string into a const wchar_t *

Is the following C++ code well-formed:

    void consumer(char const* p)
    {
      std::printf(&quot;%s&quot;, p);
    }

    std::string random_string_generator()
    {
      // returns a random std::string object
    }

    consumer(random_string_generator().c_str());

The problem I have with it is, that after creating the temporary std::string object and taking the c_str() pointer, nothing prevents the std::string object from getting destroyed (or maybe I&#39;m wrong?). Can you please point me to the standard, if the code is OK despite everything. It does work, when I test with g++.

std::string::c_str() and temporaries

I&#39;d like to build a `std::string` from a `std::vector&lt;std::string&gt;`.

I could use `std::stringsteam`, but imagine there is a shorter way:

    std::string string_from_vector(const std::vector&lt;std::string&gt; &amp;pieces) {
      std::stringstream ss;

      for(std::vector&lt;std::string&gt;::const_iterator itr = pieces.begin();
          itr != pieces.end();
          ++itr) {
        ss &lt;&lt; *itr;
      }

      return ss.str();
    }

How else might I do this?

How to construct a std::string from a std::vector&lt;string&gt;?

I need to use an `std::string` to store data retrieved by `fgets()`. To do this I need to convert the `char*` return value from `fgets()` into an `std::string` to store in an array. How can this be done?

All Stdstring Solutions on Gang of Coders

Total of 30 Stdstring Solutions