The pointer returned by `std::string::c_str()` points to memory 
maintained by the string object.  It remains valid until a non-const
function is called on the string object, or the string object is
destructed.  The string object you&#39;re concerned about is a temporary.
It will be destructed at the end of the full expression, not before and
not after.  In your case, the end of the full expression is after the
call to `consumer`, so your code is safe.  It wouldn&#39;t be if `consumer`
saved the pointer somewhere, with the idea of using it later.

The lifetime of temporaries has been strictly defined since C++98.
Before that, it varied, depending on the compiler, and the code you&#39;ve
written wouldn&#39;t have worked with g++ (pre 1995, roughly&amp;mdash;g++
changed this almost immediately when the standards committee voted it).
(There wasn&#39;t an `std::string` then either, but the same issues affect
any user written string class.)


The temporary `std::string`&#39;s lifetime extends just beyond the point where `consumer` returns, so it is safe to use anything on that string *directly from within `consumer`*. What is *not* OK is to store the value that `c_str` returns and try to use it later (the temporary will have been destroyed, and we can only guess what you will find at the other end of the pointer).

The temporary returned by the function random_string_generator() can be used in consumer() function safely.


I have an iOS app I created as a &quot;view-based app&quot; in xCode.  I have only one viewController, but it is displayed automatically, and I see no code that ties it to my appDelegate.  I need to pass data from my appDelegate to my viewController, but don&#39;t know how to pull that off.

My app delegate.h:


    #import &lt;UIKit/UIKit.h&gt;
    
    
    @interface AppDelegate : UIResponder &lt;UIApplicationDelegate&gt;
    
    @property (strong, nonatomic) UIWindow *window;
    @property (strong, nonatomic) NSDictionary *queryStrings;
    
    @end

Also, appDidFinishLoadingWithOptions:

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
    {
        // Override point for customization after application launch.
        [[JMC sharedInstance] configureJiraConnect:@&quot;https://cmsmech.atlassian.net/&quot;           projectKey:@&quot;WTUPLOAD&quot; apiKey:@&quot;7fc060e1-a795-4135-89c6-a7e8e64c4b13&quot;];
        
        if ([launchOptions objectForKey:UIApplicationLaunchOptionsURLKey] != nil) {
            NSURL *url = [launchOptions objectForKey: UIApplicationLaunchOptionsURLKey];
            NSLog(@&quot;url received: %@&quot;, url);
            NSLog(@&quot;query string: %@&quot;, [url query]);
            NSLog(@&quot;host: %@&quot;, [url host]);
            NSLog(@&quot;url path: %@&quot;, [url path]);
            queryStrings = [self parseQueryString:[url query]];
            NSLog(@&quot;query dictionary: %@&quot;, queryStrings);
        }
        else {
            queryStrings = [self parseQueryString:@&quot;wtID=nil&quot;];
        }
           
        return YES;
    }




How do I access my viewController from my appDelegate? iOS

I&#39;m planning a webservice for my own use internally that takes one argument, a URL, and returns html representing the *resolved* DOM from that URL. By resolved I mean that the webservice will firstly get the page at that URL, then use PhantomJS to &#39;render&#39; the page, and then return the resulting source after all DHTML, AJAX calls etc are executed. However launching phantom on a per-request basis (which I&#39;m doing now) is *way* too sluggish. I would rather have a pool of PhantomJS instances with one always available to serve the latest call to my webservice.

Has any work been done on this kind of thing before? I&#39;d rather base this webservice on the work of others than write a pool manager / http proxy server for myself from scratch.

**More Context**: I&#39;ve listed the 2 similar projects that I&#39;ve seen so far below and why I&#39;ve avoided each one, resulting in this question about managing a pool of PhantomJS instances instead.

jsdom - from what I&#39;ve seen it has great functionality for executing scripts on a page, but it doesn&#39;t attempt to replicate browser behaviour, so if I were use it as a general purpose &quot;DOM resolver&quot; there&#39;d end up being a lot of extra coding to handle all kinds of edges cases, event calling, etc. The first example I saw was having to manually call the onload() function of the body tag for a test app I set up using node. It seemed like the beginning of a deep rabbit hole.

Selenium - It just has soo many more moving parts, so setting up a pool to manage long lived browser instances will just be more complicated than using PhantomJS. I don&#39;t need any of it&#39;s macro recording / scripting benefits. I just want a webservice that is as performant at getting a webpage and resolving it&#39;s DOM as if I were browsing to that URL with a browser (or even faster if I can make it ignore images etc.)

How to manage a &#39;pool&#39; of PhantomJS instances

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

Is the following C++ code well-formed:
<pre><code class="hljs language-c">void consumer(char const* p)
{
 std::printf("%s", p);
}

std::string random_string_generator()
{
 // returns a random std::string object
}

consumer(random_string_generator().c_str());
</code></pre>
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'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++.

is this allowed to pass an array by reference ?

     void foo(double&amp; *bar) 

Seems that my compiler says no. Why? What is the proper way to pass an array by reference? Or a work around? I have an array argument that my method should modify and that I should retrieve afterwards. Alternatively, I could make this array a class member, which works fine, but it has many drawbacks for other part of my code (that I would like to avoid).

Thanks and regards.

C++ pass an array by reference

I am running Eclipse Helios and I have g++-4.6 installed. Hope I am not wrong that g++4.6 implements C++ 11 features. I have created a C++ project which uses the nullptr and auto keywords. The build gives the following errors:-

    ../{filename}.cpp:13:13: error: ‘nullptr’ was not declared in this scope
    
    ../{filename}.cpp:14:2: warning: ‘auto’ will change meaning in C++0x; please remove it [-Wc++0x-compat]

Actually it was building fine until yesterday. I am getting these from nowhere today. Please help me solve this problem.


C++ Error &#39;nullptr was not declared in this scope&#39; in Eclipse IDE

I would like to remove a key from a STL map. However,   `map.erase()` doesn&#39;t do anything.
How would I go about doing this


Remove a key from a C++ map

We have a set of [cross-platform CMake build scripts][1], and we support building with [Visual C++][2] and [GCC][3].

We&#39;re trying out [Clang][4], but I can&#39;t figure out how to test whether or not the compiler is Clang with our CMake script.

What should I test to see if the compiler is Clang or not? We&#39;re currently using [`MSVC`][5] and [`CMAKE_COMPILER_IS_GNU&lt;LANG&gt;`][6] to test for Visual C++ and GCC, respectively.

  [1]: https://code.asterisk.org/code/browse/astscf-cmake-release/AsteriskSCF.cmake?r=HEAD
  [2]: http://msdn.microsoft.com/en-us/vstudio/aa718325
  [3]: http://gcc.gnu.org/
  [4]: http://clang.llvm.org/
  [5]: http://www.cmake.org/cmake/help/v2.8.8/cmake.html#variable:MSVC
  [6]: http://www.cmake.org/cmake/help/v2.8.8/cmake.html#variable%3aCMAKE_COMPILER_IS_GNULANG




In CMake, how can I test if the compiler is Clang?

I have 2 files, A.cpp and B.cpp, in a Win32 console application.

Both 2 files contain only the following 2 lines of code:

    #include &quot;stdafx.h&quot;
    int k;

When compiling it produces the error

    Error	1	error LNK2005: &quot;int k&quot; (?a@@3HA) already defined in A.obj

I don&#39;t understand what is happening.

Can someone please explain this to me?


error LNK2005, already defined?

Can I initialize an STL vector with 10 of the same integer in an initializer list?  My attempts so far have failed me.

Can I initialize an STL vector with 10 of the same integer in an initializer list?

Does someone know the way to define constant-sized vector?

For example, instead of defining

    std::vector&lt;int&gt;

it will be

    std::vector&lt;10, int&gt;

**It should be completely cross-platformed**. Maybe an open source class?

Constant-sized vector

I&#39;m making a C++ wrapper for a piece of C code that returns a large array, and so I&#39;ve tried to return the data in a `vector&lt;unsigned char&gt;`.

Now the problem is, the data is on the order of **megabytes**, and `vector` unnecessarily *initializes* its storage, which essentially turns out to cut down my speed by half.

How do I prevent this?

Or, if it&#39;s not possible -- is there some other STL container that would avoid such needless work? Or must I end up making my own container?

(Pre-C++11)

### Note:

I&#39;m passing the vector *as my output buffer*. I&#39;m **not** copying the data from elsewhere.  
It&#39;s something like:

    vector&lt;unsigned char&gt; buf(size);   // Why initialize??
    GetMyDataFromC(&amp;buf[0], buf.size());

C++ vector that *doesn&#39;t* initialize its members?

Code:

    std::vector&lt;int&gt; x{1,2,3,4};
    std::array&lt;int, 4&gt; y{{1,2,3,4}};

Why do I need double curly braces for std::array?


Why is the C++ initializer_list behavior for std::vector and std::array different?

I have a `vector&lt;CustomClass*&gt;` and I put a lot of items in the vector and I need fast access, so I don&#39;t use list. How to set initial size of vector (for example to be 20 000 places, so to avoid copy when I insert new)?

How to set initial size of std::vector?

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

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?

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

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;



Content Type	Original Author	Original Content on Stackoverflow
Question	user1095108	View Question on Stackoverflow
Solution 1 - C++	James Kanze	View Answer on Stackoverflow
Solution 2 - C++	Jon	View Answer on Stackoverflow
Solution 3 - C++	dgulabs	View Answer on Stackoverflow

std::string::c_str() and temporaries

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

How to manage a 'pool' of PhantomJS instances

How do I access my viewController from my appDelegate? iOS

Attributions