It depends on the order of member variable declaration in the class. So `a_` will be the first one, then `b_` will be the second one in your example.

To quote the standard, for clarification:

&gt; 12.6.2.5

&gt;Initialization shall proceed in the following order:

&gt; **...**

&gt; - Then, nonstatic data members shall be initialized in the order they were declared in the class definition
(again regardless of the order of the mem-initializers).

&gt; **...**

The [standard reference][1] for this now appears to be 12.6.2 section 13.3:

&gt; (13.3) — Then, non-static data members are initialized in the order they were declared in the class definition
(again regardless of the order of the mem-initializers).

[1]: http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/n4594.pdf

How are `\r` and `\n` different? I think it has something to do with Unix vs. Windows vs. Mac, but I&#39;m not sure exactly how they&#39;re different, and which to search for/match in regexes.

What is the difference between \r and \n?

I&#39;m not sure what is the proper syntax for using C enums. I have the following code:

    enum {RANDOM, IMMEDIATE, SEARCH} strategy;
    strategy = IMMEDIATE;

But this does not compile, with the following error:

    error: conflicting types for ‘strategy’
    error: previous declaration of ‘strategy’ was here

What am I doing wrong?

How to define an enumerated type (enum) in C?

I have a constructor that takes some arguments.  I had assumed that they were constructed in the order listed, but in one case it appears they were being constructed in reverse resulting in an abort. When I reversed the arguments the program stopped aborting.  This is an example of the syntax I&#39;m using.  The thing is, a_ needs to be initialized before b_ in this case.  Can you guarantee the order of construction? 


e.g.

    class A
    {
      public:
        A(OtherClass o, string x, int y) :
          a_(o), b_(a_, x, y) { }
    
        OtherClass a_;
        AnotherClass b_;
    };

Constructor initialization-list evaluation order

I have a constructor that takes some arguments. I had assumed that they were constructed in the order listed, but in one case it appears they were being constructed in reverse resulting in an abort. When I reversed the arguments the program stopped aborting. This is an example of the syntax I'm using. The thing is, a_ needs to be initialized before b_ in this case. Can you guarantee the order of construction?
e.g.
<pre><code class="hljs language-css">class A
{
 public:
 A(OtherClass o, string x, int y) :
 a_(o), b_(a_, x, y) { }

 OtherClass a_;
 AnotherClass b_;
};
</code></pre>

I have a C++ source file and a Python source file. I&#39;d like the C++ source file to be able to use the contents of the Python source file as a big string literal. I could do something like this:

    char* python_code = &quot;
    #include &quot;script.py&quot;
    &quot;

But that won&#39;t work because there need to be \&#39;s at the end of each line. I could manually copy and paste in the contents of the Python code and surround each line with quotes and a terminating \n, but that&#39;s ugly. Even though the python source is going to effectively be compiled into my C++ app, I&#39;d like to keep it in a separate file because it&#39;s more organized and works better with editors (emacs isn&#39;t smart enough to recognize that a **C** string literal is python code and switch to python mode while you&#39;re inside it).

Please don&#39;t suggest I use PyRun_File, that&#39;s what I&#39;m trying to avoid in the first place ;)

C/C++, can you #include a file into a string literal?

In C++, why is private the default visibility for members of classes, but public for structs?

default visibility of C++ class/struct members

Once in a while, I find myself rounding some numbers, and I always have to cast the result to an integer:

    int rounded = (int) floor(value);

Why do all rounding functions (`ceil()`, `floor()`) return a floating number, and not an integer? I find this pretty non-intuitive, and would love to have some explanations!

Why do round() and ceil() not return an integer?

I want to iterate over all files in a directory matching something like `somefiles*.txt`. 

Does `boost::filesystem` have something built in to do that, or do I need a regex or something against each `leaf()`?


Can I use a mask to iterate files in a directory with Boost?

Is it possible to use the `break` function to exit several nested `for` loops?

If so, how would you go about doing this? Can you also control how many loops the `break` exits?



Can I use break to exit multiple nested &#39;for&#39; loops?

In the example code

    void foo()
    {
      static Bar b;
      ...
    }

compiled with **GCC** is it guaranteed that `b` will be created and initialized in a thread-safe manner ?

In gcc&#39;s man page, found the **-fno-threadsafe-statics** command line option:

&gt; Do not emit the extra code to use the
&gt; routines specified in the C++ ABI for
&gt; thread-safe initialization of local
&gt; statics. You can use this option to
&gt; reduce code size slightly in code that
&gt; doesn&#39;t need to be thread-safe.

1. Does it mean, that local statics are thread-safe by default with GCC ? So no reason to put explicit guarding e.g. with `pthread_mutex_lock/unlock` ?

2. How to write portable code - how to check if compiler will add its guards ? Or is it better to turn off this feature of GCC ?

Are function static variables thread-safe in GCC?

Is it possible to compile a project in **32-bit** with `cmake` and `gcc` on a **64-bit** system? It probably is, but how do I do it?

When I tried it the &quot;ignorant&quot; way, without setting any parameters/flags/etc, just setting `LD_LIBRARY_PATH` to find the linked libraries in `~/tools/lib` it seems to ignore it and only look in subdirectories named _lib64_.

How to compile a 32-bit binary on a 64-bit linux machine with gcc/cmake

Can someone elaborate on the following gcc error?

    $ gcc -o Ctutorial/temptable.out temptable.c 
    temptable.c: In function ‘main’:
    temptable.c:5: error: ‘for’ loop initial declaration used outside C99 mode

temptable.c:

    ...
    /* print Fahrenheit-Celsius Table */
    main()
    {
    	for(int i = 0; i &lt;= 300; i += 20)
    	{
    		printf(&quot;F=%d C=%d\n&quot;,i, (i-32) / 9);		
    	}
    }

P.S: I vaguely recall that `int i` should be declared before a `for` loop. I should state that I am looking for an answer that gives a historical context of C standard.


C: for loop int initial declaration

I was wondering how to use [GCC][1] on my C source file to dump a mnemonic version of the machine code so I could see what my code was being compiled into. You can do this with Java but I haven&#39;t been able to find a way with GCC.

I am trying to re-write a C method in assembly and seeing how GCC does it would be a big help.

  [1]: http://en.wikipedia.org/wiki/GNU_Compiler_Collection


Using GCC to produce readable assembly?

I wonder how to check the version of OpenMP on a Linux remote machine? 

I don&#39;t know where it is installed either.

How to check the version of OpenMP on Linux

I want to understand the external linkage and internal linkage and their difference. 

I also want to know the meaning of

&gt; `const` variables internally link by default unless otherwise declared as `extern`.

What is external linkage and internal linkage?

What is the difference between a definition and a declaration?

I&#39;ve been told by others that writing `using namespace std;` in code is wrong, and that I should use `std::cout` and `std::cin` directly instead.

Why is `using namespace std;` considered a bad practice? Is it inefficient or does it risk declaring ambiguous variables (variables that share the same name as a function in `std` namespace)? Does it impact performance?

Why is &quot;using namespace std;&quot; considered bad practice?

I recently had a problem creating a `stringstream` due to the fact that I incorrectly assumed `std::setw()` would affect the stringstream for every insertion, until I changed it explicitly. However, it is always unset after the insertion.

&lt;!-- language: cpp --&gt;

    // With timestruct with value of &#39;Oct 7 9:04 AM&#39;
    std::stringstream ss;
    ss.fill(&#39;0&#39;); ss.setf(ios::right, ios::adjustfield);
    ss &lt;&lt; setw(2) &lt;&lt; timestruct.tm_mday;
    ss &lt;&lt; timestruct.tm_hour;
    ss &lt;&lt; timestruct.tm_min;
    std::string filingTime = ss.str(); // BAD: &#39;0794&#39;

So, I have a number of questions:

 - Why is `setw()` this way? 
 - Are any other manipulators this way? 
 - Is there a difference in behavior between `std::ios_base::width()` and `std::setw()`? 
 - Finally is there an online reference that clearly documents this behavior? My vendor documentation (MS Visual Studio 2005) doesn&#39;t seem to clearly show this.

Which iomanip manipulators are &#39;sticky&#39;?

Why is it not allowed to get non-const reference to a temporary object, 
which function `getx()` returns? Clearly, this is prohibited by C++ Standard 
but I am interested in the purpose of such restriction, **not a reference** to the standard. 

    struct X
    {
    	X&amp; ref() { return *this; }
    };
    
    X getx() { return X();}

    void g(X &amp; x) {}    
    
    int f()
    {
    	const X&amp; x = getx(); // OK
    	X&amp; x = getx(); // error
    	X&amp; x = getx().ref(); // OK
    	g(getx()); //error
    	g(getx().ref()); //OK
    	return 0;
    }

 1. It is clear that the lifetime of the object cannot be the cause, because 
constant reference to an object is *not prohibited* by C++ Standard.
 2. It is clear that the temporary object is not constant in the sample above, because calls to non-constant functions are permitted. For instance, `ref()` could modify the temporary object.  
 3. In addition, `ref()` allows you to fool the compiler and get a link to this temporary object and that solves our problem.

**In addition:**

They say &quot;assigning a temporary object to the const reference extends the lifetime of this object&quot; and &quot; Nothing is said about non-const references though&quot;. 
My **additional question**. Does following assignment extend the lifetime of temporary object?

    X&amp; x = getx().ref(); // OK






Content Type	Original Author	Original Content on Stackoverflow
Question	hookenz	View Question on Stackoverflow
Solution 1 - C++	Khaled Alshaya	View Answer on Stackoverflow
Solution 2 - C++	GManNickG	View Answer on Stackoverflow
Solution 3 - C++	Adam Getchell	View Answer on Stackoverflow

Constructor initialization-list evaluation order

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

How to define an enumerated type (enum) in C?

What is the difference between \r and \n?

Attributions