`-fno-elide-constructors`

&gt; The C++ standard allows an implementation to omit creating a temporary which is only used to initialize another object of the same type.  Specifying this option disables that optimization, and forces G++ to call the copy constructor in all cases. [Source: man gcc]
_______________________________________________________

Calling one prototype method inside another in javascript

I want to horizontally center two (or possibly more) inline-block elements inside a container block element. It should look like this:

    --------------------------
    |      _____   _____      |
    |     |     | |     |     |
    |     | foo | | bar |     |
    |     |_____| |_____|     |
    |_________________________|

However, with my broken code, it is currently looking like this:

    --------------------------
    | _____   ____            |
    ||     | |     |          |
    || foo | | bar |          |
    ||_____| |_____|          |
    |_________________________|

**HTML**

    &lt;div&gt;
     &lt;a&gt;foo&lt;/a&gt;
     &lt;a&gt;bar&lt;/a&gt;
    &lt;/div&gt;

**CSS**

    div a {
     display: inline-block;
     padding: 1em;
     margin: 1em;
     border: 1px solid black;
    }

The reason why the two anchors have to be inline-block and not just plain inline is because I don&#39;t want the anchor&#39;s padding and margin to overlap.


How to center multiple inline-block elements with CSS?

What flag(s) do I need on the command line to disable the return-value optimisation automatically enabled by the g++ compiler?

Disabling g++&#39;s return-value optimisation

<p>What flag(s) do I need on the command line to disable the return-value optimisation automatically enabled by the g++ compiler?</p>


In a recent interview, I was asked a really strange question. The interviewer asked me how can I compute 1+2+3+...+1000 just using compiler features. This means that I am not allowed to write a program and execute it, but I should just write a program that could drive the compiler to compute this sum while compilation and print the result when compilation completes. As a hint, he told me that I may use generics and pre-processor features of the compiler. It is possible to use C++, C# or Java compiler. Any ideas???

This question is not related to computing the sum without any loops [asked here][1]. In addition, It should be noted that the sum SHOULD be calculated during compilation. Printing just the result using C++ compiler directives is not acceptable. 

&lt;hr&gt;

Reading more about the posted answers, I found that solving problems during compilation using C++ templates is called **metaprogramming**. This is a technique that was discovered accidentally by Dr. Erwin Unruh,  during the process of standardizing the C++ language. You may read more about this topic on [wiki page of meta-programming][2].
It seems that it is possible to write the program in Java using java annotations. You may take a look at **[maress&#39;s][3]** answer below. 

A nice book about meta-programming in C++ is [this one][4]. Worth to take a look if interested. 

A useful C++ meta-programming library is Boost&#39;s MPL [this link][5].


  [1]: https://stackoverflow.com/questions/4568645/printing-1-to-1000-without-loop-or-conditionals/4568650#4568650
  [2]: http://en.wikipedia.org/wiki/Template_metaprogramming
  [3]: https://stackoverflow.com/a/8815298/114029
  [4]: http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
  [5]: http://www.boost.org/doc/libs/1_58_0/libs/mpl/doc/index.html

How to drive C#, C++ or Java compiler to compute 1+2+3+...+1000 at compile time?

I have a function which I want to take, as a parameter, a 2D array of variable size. 

So far I have this: 

    void myFunction(double** myArray){
         myArray[x][y] = 5;
         etc...
    }

And I have declared an array elsewhere in my code:
   
    double anArray[10][10];

However, calling `myFunction(anArray)` gives me an error.

I do not want to copy the array when I pass it in. Any changes made in `myFunction` should alter the state of `anArray`. If I understand correctly, I only want to pass in as an argument a pointer to a 2D array. The function needs to accept arrays of different sizes also. So for example, `[10][10]` and `[5][5]`. How can I do this?


Passing a 2D array to a C++ function

What is the simplest way to convert array to vector?

    void test(vector&lt;int&gt; _array)
    {
      ...
    }
    
    int x[3]={1, 2, 3};
    test(x); // Syntax error.

I want to convert x from int array to vector&lt;int&gt; in simplest way.

What is the simplest way to convert array to vector?

I would like to store instances of several classes in a vector. Since all classes inherit from the same base class this should be possible.

Imagine this program:

    #include &lt;iostream&gt;
    #include &lt;vector&gt;
    using namespace std;
    
    class Base
    {
        public:
        virtual void identify ()
        {
            cout &lt;&lt; &quot;BASE&quot; &lt;&lt; endl;
        }
    };
    
    class Derived: public Base
    {
        public:
        virtual void identify ()
        {
            cout &lt;&lt; &quot;DERIVED&quot; &lt;&lt; endl;
        }
    };
    
    int main ()
    {
        Derived derived;
        
        vector&lt;Base&gt; vect;
        vect.push_back(derived);
        
        vect[0].identify();
        return 0;
    }
I expected it to print &quot;DERIVED&quot;, because the &quot;identify&quot; method is virtual. Instead &#39;vect[0]&#39; seems to be a &#39;Base&#39; instance and it prints
&gt; BASE

I guess I could write my own container (probably derived from vector) somehow that is capable of doing this (maybe holding only pointers...). I just wanted to ask if there is a more C++ish method for doing this. AND I would like to be completely vector-compatible (just for convenience if other users should ever use my code).








Store derived class objects in base class variables

I understand most operator overloading, with the exception of the member access operators `-&gt;`, `.*`, `-&gt;*` etc.

In particular, what is passed to these operator functions, and what should be returned?

How does the operator function (e.g. `operator-&gt;(...)` ) know what member is being refered to? Can it know? Does it even need to know?

Finally, are there any const considerations that need to be taken into account? For example, when overloading something like `operator[]`, generally you will need both a const and non-const version. Do member access operators require const and non-const versions?

Overloading member access operators -&gt;, .*

Why does the following work fine?

    String str;
    while (condition) {
        str = calculateStr();
        .....
    }

But this one is said to be dangerous/incorrect:

    while (condition) {
        String str = calculateStr();
        .....
    }

Is it necessary to declare variables outside the loop?

Declaring variables inside or outside of a loop

I have a query of the following form:

    SELECT * FROM MyTable WHERE Timestamp &gt; [SomeTime] AND Timestamp &lt; [SomeOtherTime]

I would like to optimize this query, and I am thinking about putting an index on timestamp, but am not sure if this would help. Ideally I would like to make timestamp a clustered index, but MySQL does not support clustered indexes, except for primary keys.

 - `MyTable` has 4 million+ rows.
 - `Timestamp` is actually of type `INT`.
 - Once a row has been inserted, it is never changed.
 - The number of rows with any given `Timestamp` is on average about 20, but could be as high as 200.
 - Newly inserted rows have a `Timestamp` that is greater than most of the existing rows, but could be less than some of the more recent rows.

Would an index on `Timestamp` help me to optimize this query?

Creating an index on a timestamp to optimize query

I have recently discovered existence of standard _fastest_ type, mainly [int_fast32_t][1] and [int_fast64_t][2].

I was always told that, for normal use on mainstream architecture, one should better use classical _int_ &amp; _long_ which should always fit to the processor default reading capacity and so avoid useless numeric conversions.

In the C99 Standard, it says in &#167;7.18.1.3p2 : 
&gt; &quot;The typedef name int_fastN_t designates the fastest signed integer type with a width of at least N. The typedef name uint_fastN_t designates the fastest unsigned integer type with a width of at least N.&quot;

And there is also a quote about it in &#167;7.18.1.3p1 :
&gt; &quot;The designated type is not guaranteed to be fastest for all purposes; if the implementation has no clear grounds for choosing one type over another, it will simply pick some integer type satisfying the signedness and width requirements.&quot;

It&#39;s unclear to me what _fastest_ really means. I do not understand when I should use this type and when I should not. 

I have googled a little on this and found that some [open][3] [source][4] [projects][5] have changed some of their functions to it, but not all of them. They didn&#39;t really explain why they have changed a part, and _only_ a part, of their code to it.

Do you know what are the specific cases/usages when int_fastXX_t are _really_ faster than the classical ones ? 


  [1]: http://www.linuxbase.org/navigator/browse/type_single.php?cmd=display&amp;Tid=16619
  [2]: http://www.linuxbase.org/navigator/browse/type_single.php?cmd=display&amp;Tid=16620
  [3]: http://lists.gnu.org/archive/html/qemu-devel/2011-03/msg00454.html
  [4]: http://cekirdek.pardus.org.tr/~ismail/ffmpeg-docs/simple__idct__alpha_8c.html
  [5]: http://patchwork.ozlabs.org/patch/85610/

What is the difference between intXX_t and int_fastXX_t?

I am trying to optimize a site performance by consolidating and compressing the CSS and JS files. My question is more about the (concrete) steps on how to achieve this, given a real situation I was facing (should be typical among other developers too, though).

My page references several CSS and JS files like the following:

    &lt;!--
      It&#39;s easier to work on smaller files during development.
      Hence, the multiple CSS and JS files.
    --&gt;
    &lt;link type=&quot;text/css&quot; rel=&quot;stylesheet&quot; href=&quot;/css/main.css&quot; /&gt;
    &lt;link type=&quot;text/css&quot; rel=&quot;stylesheet&quot; href=&quot;/css/secondary-1.css&quot; /&gt;
    &lt;link type=&quot;text/css&quot; rel=&quot;stylesheet&quot; href=&quot;/css/secondary-2.css&quot; /&gt;
    
    &lt;script type=&quot;text/javascript&quot; src=&quot;/scripts/js/main.js&quot;&gt;&lt;/script&gt;
    &lt;script type=&quot;text/javascript&quot; src=&quot;/scripts/js/adapter/adapter.js&quot;&gt;&lt;/script&gt;
    &lt;script type=&quot;text/javascript&quot; src=&quot;/scripts/js/adapter/title-adapter.js&quot;&gt;&lt;/script&gt;

For the production release, I&#39;d like to combine the 3 CSS files into one and minify it using e.g. [YUI Compressor][1]. But then, I&#39;d need to update all pages that needs these 3 files to reference to the newly-minified CSS. This seems error-prone (e.g. you&#39;re removing and adding some lines in many files). Any other less-risky approach? The same issue for the JS files.

  [1]: http://developer.yahoo.com/yui/compressor/

Combine and Minify Multiple CSS / JS Files

I&#39;m looking for the best way to get the first and the last  day of a last month. I use them for make SQL queries to get stats of last month.

I think that this is the best way, more optimized but not more comprensive, anyone have another way to do the same? 

        $month_ini = date(&quot;Y-m-d&quot;, mktime(0, 0, 0, date(&quot;m&quot;, strtotime(&quot;-1 month&quot;)), 1, date(&quot;Y&quot;, strtotime(&quot;-1 month&quot;))));

        $month_end = date(&quot;Y-m-d&quot;, mktime(0, 0, 0, date(&quot;m&quot;, strtotime(&quot;-1 month&quot;)), date(&quot;t&quot;, strtotime(&quot;-1 month&quot;)), date(&quot;Y&quot;, strtotime(&quot;-1 month&quot;))));

Thanks!!

The best way to get the first and last day of last month?

I&#39;m a newbie in `clang`. I have read a paper about source to source transformation from `cuda` to `opencl` using `clang` compiler front end.

Can anyone tell me why the option `-cc1` is sometimes used?


What does the clang -cc1 option do?

Both of them pretty much do the same thing. Identify that the method is hot and compile it instead of interpreting. With OSR, you just move to the compiled version right after it gets compiled, unlike with JIT, where the compiled code gets called when the method is called for the second time. 

Other than this, are there any other differences?

Differences between Just in Time compilation and On Stack Replacement

Suppose I have an `if` statement with a `return`. From the efficiency perspective, should I use

    if(A &gt; B):
        return A+1
    return A-1

or

    if(A &gt; B):
        return A+1
    else:
        return A-1

Should I prefer one or another when using a compiled language (C) or a scripted one (Python)?

It is more efficient to use if-return-return or if-else-return?

This has been bugging me for a while. How do GCC and g++ compile themselves?

I&#39;m guessing that every revision gets compiled with a previously built revision. Is this true? And if it is, does it mean that the oldest g++ and GCC versions were written in assembly?



How are GCC and g++ bootstrapped?

In PHP and C# the constants can be initialized as they are declared:

    class Calendar3
    {
        const int value1 = 12;
        const double value2 = 0.001;
    }

I have the following C++ declaration of a functor which is used with another class to compare two math vectors:

    struct equal_vec
    {
        bool operator() (const Vector3D&amp; a, const Vector3D&amp; b) const
        {
            Vector3D dist = b - a;
            return ( dist.length2() &lt;= tolerance );
        }
    
        static const float tolerance = 0.001;
    };

This code compiled without problems with g++. Now in C++0x mode (-std=c++0x) the g++ compiler outputs an error message:

&gt; error: ‘constexpr’ needed for in-class initialization of static data member ‘tolerance’ of non-integral type

I know I can define and initialize this `static const` member outside of the class definition. Also, a non-static constant data member can be initialized in the initializer list of a constructor.

But is there any way to initialize a constant within class declaration just like it is possible in PHP or C#?

&lt;h3&gt;Update&lt;/h3&gt;

I used `static` keyword just because it was possible to initialize such constants within the class declaration in g++. I just need a way to initialize a constant in a class declaration no matter if it declared as `static` or not.


Initializing const member within class declaration in C++

I am looking for help getting started with a project involving CUDA. My goal is to have a project that I can compile in the native g++ compiler but uses CUDA code. I understand that I have to compile my CUDA code in nvcc compiler, but from my understanding I can somehow compile the CUDA code into a cubin file or a ptx file.

Here are my questions:

1. How do I use nvcc to compile into a cubin file or a ptx file? Don&#39;t I need a -c or something?
2. Which file type do I want to use?
3. What are the g++ commands to correctly compile and link the project together?

Assume the following:

1. I have a file called &quot;main.cpp&quot; that has a main function in it and includes cuda.h.
2. I have another file called &quot;cudaFunc.cu&quot; that has CUDA code in it. Let&#39;s say, for instance, that I want to add two integer arrays that exist in main.cpp.

How can I compile CUDA code then link it to a C++ project?

I was just playing around with g++ 4.7 (one of the later snapshots) with -std=c++11 enabled. I tried to compile some of my existing code base and one case that failed somewhat confuses me.

I would appreciate if someone can explain what is going on.

Here&#39;s the code:

    #include &lt;utility&gt;
    #include &lt;iostream&gt;
    #include &lt;vector&gt;
    #include &lt;string&gt;

    int main ( )
    {
        std::string s = &quot;abc&quot;;

        // 1 ok
        std::pair &lt; std::string, int &gt; a = std::make_pair ( s, 7 );
        
        // 2 error on the next line
        std::pair &lt; std::string, int &gt; b = std::make_pair &lt; std::string, int &gt; ( s, 7 );

        // 3 ok
        std::pair &lt; std::string, int &gt; d = std::pair &lt; std::string, int &gt; ( s, 7 );

        return 0;
    }

I understand that make_pair is _meant_ to be used as the (1) case (if I specify the types, then I might as well use (3)), but I don&#39;t understand why it&#39;s failing in this case.

The exact error is:
 
```
test.cpp: In function ‘int main()’:
    test.cpp:11:83: error: no matching function for call to ‘make_pair(std::string&amp;, int)’
    test.cpp:11:83: note: candidate is:
    In file included from /gcc4.7/usr/local/lib/gcc/i686-pc-linux-gnu/4.7.0/../../../../include/c++/4.7.0/utility:72:0,
                 from test.cpp:1:
    /gcc4.7/usr/local/lib/gcc/i686-pc-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:274:5:
note: template&lt;class _T1, class _T2&gt; constexpr std::pair&lt;typename std::__decay_and_strip&lt;_T1&gt;::__type, typename std::__decay_and_strip&lt;_T2&gt;::__type&gt; std::make_pair(_T1&amp;&amp;, _T2&amp;&amp;)
    /gcc4.7/usr/local/lib/gcc/i686-pc-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:274:5:
note:   template argument deduction/substitution failed:
    test.cpp:11:83: note:   cannot convert ‘s’ (type ‘std::string {aka std::basic_string&lt;char&gt;}’) to type ‘std::basic_string&lt;char&gt;&amp;&amp;’
```
Again, the question here is just &quot;what&#39;s going on?&quot; I know that I can fix the problem by removing the template specification, but I just want to know what&#39;s failing here under the covers.

- g++ 4.4 compiles this code with no problems.
- Removing -std=c++11 also compiles with code with no problems.


C++11 make_pair with specified template parameters doesn&#39;t compile

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&#39;m trying to update my C++ compiler to C++11.
I have searched a bit and I have come to the conclusion that I have to use the flag `-std=c++0x` or `-std=gnu++0x`, but I don&#39;t know many things about flags. Can anyone help me? (I&#39;m using Ubuntu 12.04.)

Here is the error that I get from the compiler when I attempt to use a library which is included in C++11 (i.e. array):

    #include &lt;array&gt;
    #include &lt;iostream&gt;
    
    int main()
    {
        std::array&lt;int, 3&gt; arr = {2, 3, 5};
        ...
    }
    

&gt; This file requires compiler and library support for the upcoming ISO C++ standard, C++0x. This support is currently experimental, and must be enabled with the -std=c++0x or -std=gnu++0x compiler options.

Compiling C++11 with g++

What is copy elision? What is (named) return value optimization? What do they imply?

In what situations can they occur? What are limitations?

- If you were referenced to this question, you&#39;re probably looking for [**the introduction**][1].
- For a technical overview, see [**the standard reference**][2].
- See [**common cases** here][3].


  [1]: https://stackoverflow.com/a/12953129/673730
  [2]: https://stackoverflow.com/a/12953145/673730
  [3]: https://stackoverflow.com/a/12953150/673730

What are copy elision and return value optimization?

I don&#39;t understand when I should use `std::move` and when I should let the compiler optimize... for example:

    using SerialBuffer = vector&lt; unsigned char &gt;;

    // let compiler optimize it
    SerialBuffer read( size_t size ) const
    {
        SerialBuffer buffer( size );
        read( begin( buffer ), end( buffer ) );
        // Return Value Optimization
        return buffer;
    }

    // explicit move
    SerialBuffer read( size_t size ) const
    {
        SerialBuffer buffer( size );
        read( begin( buffer ), end( buffer ) );
        return move( buffer );
    }

Which should I use?

c++11 Return value optimization or move?

In many cases when returning a local from a function, RVO (return value optimization) kicks in. However, I thought that explicitly using `std::move` would at least enforce moving when RVO does not happen, but that RVO is still applied when possible. However, it seems that this is not the case.

    #include &quot;iostream&quot;

    class HeavyWeight
    {
    public:
        HeavyWeight()
        {
            std::cout &lt;&lt; &quot;ctor&quot; &lt;&lt; std::endl;
        }

        HeavyWeight(const HeavyWeight&amp; other)
        {
            std::cout &lt;&lt; &quot;copy&quot; &lt;&lt; std::endl;
        }

        HeavyWeight(HeavyWeight&amp;&amp; other)
        {
            std::cout &lt;&lt; &quot;move&quot; &lt;&lt; std::endl;
        }
    };

    HeavyWeight MakeHeavy()
    {
        HeavyWeight heavy;
        return heavy;
    }

    int main()
    {
        auto heavy = MakeHeavy();
        return 0;
    }

I tested this code with VC++11 and GCC 4.71, debug and release (`-O2`) config. The copy ctor is never called. The move ctor is only called by VC++11 in debug config. Actually, everything seems to be fine with these compilers in particular, but to my knowledge, RVO is optional.

However, if I explicitly use `move`:

    HeavyWeight MakeHeavy()
    {
        HeavyWeight heavy;
        return std::move(heavy);
    }
the move ctor is always called. So trying to make it &quot;safe&quot; makes it worse.

My questions are:  
 - Why does `std::move` prevent RVO?  
 - When is it better to &quot;hope for the best&quot; and rely on RVO, and when should I explicitly use `std::move`? Or, in other words, how can I let the compiler optimization do its work and still enforce move if RVO is not applied?


Why does std::move prevent RVO (return value optimization)?

Some people are not aware that it&#39;s [possible to pass and return structs by value in C](https://stackoverflow.com/questions/9653072/return-a-struct-from-a-function-in-c). My question is about the compiler making unnecessary copies when returning structs in C.  Do C compilers such as GCC use [Return value optimization(RVO)](https://en.wikipedia.org/wiki/Return_value_optimization) optimization or is this a C++ only concept? Everything I have read about RVO and copy elision is in regards to C++.

Let&#39;s consider an example.
I&#39;m currently implementing a [double-double data type](https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#Double-double_arithmetic) in C (or rather float-float to start with because I find it easy to unit test).  Consider the following code.

    typedef struct {
    	float hi;
    	float lo;
    } doublefloat;
    
    doublefloat quick_two_sum(float a, float b) {
    	float s = a + b;
    	float e = b - (s - a);
    	return (doublefloat){s, e};
    }

Will the compiler make a temporary copy of the `doublefloat` value I return or can the temporary copy be elided?

What about named return value optimization (NRVO) in C?  I have another function 

    doublefloat df64_add(doublefloat a, doublefloat b) {
    	doublefloat s, t;
    	s = two_sum(a.hi, b.hi);
    	t = two_sum(a.lo, b.lo);
    	s.lo += t.hi;
    	s = quick_two_sum(s.hi, s.lo);
    	s.lo += t.lo;
    	s = quick_two_sum(s.hi, s.lo);
    	return s;
    }

In this case i&#39;m returning a named struct. Can the temporary copy in this case be elided?

It should be stated that this is a general question for C and that the code examples I have used here are only examples (when I optimize this I will be using SIMD with intrinsics anyway). I&#39;m aware that I could look at the assembly output to see what the compiler does but I think this is an interesting question nevertheless.

Content Type	Original Author	Original Content on Stackoverflow
Question	cpp_noname	View Question on Stackoverflow
Solution 1 - C++	Prasoon Saurav	View Answer on Stackoverflow

Disabling g++'s return-value optimisation

C++ Problem Overview

C++ Solutions

Solution 1 - C++

How to center multiple inline-block elements with CSS?

Calling one prototype method inside another in javascript

Attributions