Look at the documentation [`string::find`][1]  

    std::string s = &quot;hell[o&quot;;
    if (s.find(&#39;[&#39;) != std::string::npos)
        ; // found
    else
        ; // not found


  [1]: http://en.cppreference.com/w/cpp/string/basic_string/find

Starting from C++23 you can use [std::string::contains](https://en.cppreference.com/w/cpp/string/basic_string/contains)

```
#include &lt;string&gt;

const auto test = std::string(&quot;test&quot;);

if (test.contains(&#39;s&#39;))
{
    // found!
}
```

I did it in this way. 

```cpp
string s = &quot;More+&quot;;

if(s.find(&#39;+&#39;)&lt;s.length()){ //to find +
    //found
} else {
    //not found
}
```

It works even if you want to find more than one character but they should be lined up together. Be sure to replace `&#39;&#39;` with `&quot;&quot;`:

```cpp
string s = &quot;More++&quot;;

if(s.find(&quot;++&quot;)&lt;s.length()){ //to find ++
    //found
} else {
    //not found
}
```

In strings, we can use `find()` to get the first occurrence (position) of the given &quot;string&quot;

    string s = &quot;dumm[y[&quot;;
    int found = s.find(&#39;[&#39;);

    cout&lt;&lt;&quot;$ is present at position &quot;&lt;&lt;firstOccurrence;   //$ is present at position 4

    if (found &lt; str.length()) {
		// char found
    }
    else{
        // char not found
    }




How can I stop/kill a running task on Airflow UI? I am using `LocalExecutor`.
Even if I use `CeleryExecutor`, how do can I kill/stop the running task?

How to stop/kill Airflow tasks from the UI

Setting `OutputPath` in the new Visual Studio 2017 project format automatically adds the target framework in the path. For example, if I have these set in the project file:

    &lt;TargetFramework&gt;net462&lt;/TargetFramework&gt;
    &lt;OutputPath&gt;/build/debug/&lt;OutputPath&gt;

The actual output folder will resolve to `/build/debug/net462/`, not `/build/debug/` like in the older versions.
How do I solve this without workarounds like moving things around with post build actions?




How do I set `OutputPath` in a Visual Studio 2017 project (new .csproj file format) without the target framework cluttering the resolved path?

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 have a text file that I want to read. I want to know if one of the lines contains <code>[</code> so I tried :
<pre><code class="hljs language-c">if(array[i] == "[")
</code></pre>
But this isn't working.
How can I check if a string contains a certain character?

My question is whether all integer values are guaranteed to have a perfect double representation. 

Consider the following code sample that prints &quot;Same&quot;:

    // Example program
    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    int main()
    {
      int a = 3;
      int b = 4;
      double d_a(a);
      double d_b(b);
      
      double int_sum = a + b;
      double d_sum = d_a + d_b;
      
      if (double(int_sum) == d_sum)
      {
          std::cout &lt;&lt; &quot;Same&quot; &lt;&lt; std::endl;
      }
    }

Is this guaranteed to be true for any architecture, any compiler, any values of `a` and `b`? Will any integer `i` converted to `double`, always be represented as `i.0000000000000` and not, for example, as `i.000000000001`?

I tried it for some other numbers and it always was true, but was unable to find anything about whether this is coincidence or by design.


Note: This is different from [this question][1] (aside from the language) since I am adding the two integers. 


  [1]: https://stackoverflow.com/questions/12629087/is-floatinteger-integer-guaranteed-to-be-equal-in-c

Are all integer values perfectly represented as doubles?

I recently updated visual studio 2015 and now, when i try to build *any* project it always fails and i get the error

  

&gt;   Severity	Code	Description	Project	File	Line	Suppression State
&gt;     Error	MSB8036	The Windows SDK version 8.1 was not found. Install the required version of Windows SDK or change the SDK version in the
&gt; project property pages or by right-clicking the solution and selecting
&gt; &quot;Retarget solution&quot;.	Proj	D:\Program Files (x86)\visual studio
&gt; 2017\Common7\IDE\VC\VCTargets\Platforms\Win32\PlatformToolsets\v141\Toolset.targets	34

I retargeted the solution as it said, and the problem persisted, even though the retargetting was completed.I decided to install visual studio 2017 because of this, and, lo and behold, it did the exact same thing.I&#39;m also using windows 7.

What is the problem and how can i fix it?


How to fix the error &quot;Windows SDK version 8.1&quot; was not found?

This is my sample code:

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    using namespace std;
    
    class MyClass
    {
    	string figName;
    public:
    	MyClass(const string&amp; s)
    	{
    		figName = s;
    	}
    
    	const string&amp; getName() const
    	{
    		return figName;
    	}
    };

    ostream&amp; operator&lt;&lt;(ostream&amp; ausgabe, const MyClass&amp; f)
    {
    	ausgabe &lt;&lt; f.getName();
    	return ausgabe;
    }
    
    int main()
    {
    	MyClass f1(&quot;Hello&quot;);
    	cout &lt;&lt; f1;
        return 0;
    }

If I comment out `#include &lt;string&gt;` I don&#39;t get any compiler error, I guess because it&#39;s kind of included through `#include &lt;iostream&gt;`. If I *&quot;right-click --&gt; Go to Definition&quot;* in Microsoft VS they both point to the same line in the `xstring` file:

    typedef basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;
    	string;

But when I run my program, I get an exception error:

&gt; 0x77846B6E (ntdll.dll) in OperatorString.exe: 0xC00000FD: Stack overflow (Parameter: 0x00000001, 0x01202FC4)

Any idea why I get a runtime error when commenting out `#include &lt;string&gt;`? I&#39;m using VS 2013 Express.

Why is #include &lt;string&gt; preventing a stack overflow error here?

I&#39;ve used `std::tie` without giving much thought into it. It works so I&#39;ve just accepted that:
    
    auto test()
    {
       int a, b;
       std::tie(a, b) = std::make_tuple(2, 3);
       // a is now 2, b is now 3
       return a + b; // 5
    }

But how does this *black magic* work? How does a temporary created by `std::tie` change `a` and `b`? I find this more interesting since it&#39;s a library feature, not a language feature, so surely it is something we can implement ourselves and understand.

How does std::tie work?

I have been getting into the basics of functional programming with C++. I am trying to make a function `f(a)(b)(c)` that will return `a + b + c`. I successfully implemented the function `f(a)(b)` which returns a + b. Here is the code for it:

    std::function&lt;double(double)&gt; plus2(double a){
        return[a](double b){return a + b; };
    }

I just cannot figure out how to implement the function `f(a)(b)(c)` which as I previously stated should return `a + b + c`.

Functional programming in C++. Implementing f(a)(b)(c)

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 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/

Content Type	Original Author	Original Content on Stackoverflow
Question	Robert Lewis	View Question on Stackoverflow
Solution 1 - C++	thibsc	View Answer on Stackoverflow
Solution 2 - C++	Synck	View Answer on Stackoverflow
Solution 3 - C++	Gourav	View Answer on Stackoverflow
Solution 4 - C++	Akash Srinivasan	View Answer on Stackoverflow

How to check if a string contains a char?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

How do I set `OutputPath` in a Visual Studio 2017 project (new .csproj file format) without the target framework cluttering the resolved path?

How to stop/kill Airflow tasks from the UI

Attributions