    const auto x = expr;

differs from

    auto x = expr;

as

    const X x = expr;

differs from

    X x = expr;

So use `const auto` and `const auto&amp;` a lot, just like you would if you didn&#39;t have `auto`.

Overload resolution is not affected by return type: `const` or no `const` on the lvalue `x` does not affect what functions are called in `expr`.


Maybe you are confusing `const_iterator` and `const iterator`. The first one iterates over const elements, the second one cannot iterate at all because you cannot use `operators` ++ and -- on it.

Note that you very seldom iterate from the `container.end()`. Usually you will use:

    const auto end = container.end();
    for (auto i = container.begin(); i != end; ++i) { ... }

Consider you have two templates:

    template&lt;class U&gt; void f1( U&amp; u );       // 1
    template&lt;class U&gt; void f2( const U&amp; u ); // 2

`auto` will deduce type and the variable will have the same type as the parameter `u` (as in the `// 1` case), `const auto` will make variable the same type as the parameter `u` has in the `// 2` case. So `const auto` just force `const` qualifier.


Compiler deduces the type for the auto qualifier. If a deduced type is `some_type`, `const auto` will be converted to `const some_type`. However, a good compiler will examine the whole scope of `auto` variable and find if the value of it changes anywhere. If not, compiler itself will deduce type like this: `auto` -&gt; `const some_type`. I&#39;ve tried this in Visual studio express 2012 and machine code produced is the same in both cases, I&#39;m not sure that each and every compiler will do that.
But, it is a good practice to use `const auto` for three reasons:

 - Preventing coding errors. You intended for this variable not to change but somehow somewhere in its scope, it is changed.
 - Code readability is improved.
 - You help the compiler if for some reason it doesn&#39;t deduce `const` for `auto`.



Is there a way to initialize a NVC using C# collection initializer syntax:

    NameValueCollection nvc = new NameValueCollection() { (&quot;a&quot;, &quot;1&quot;), (&quot;b&quot;, &quot;2&quot;) };

Thanks



Can I use collection initializers with a NameValueCollection?

With sl4fj if I want to construct a string message there is a nice approach which makes use of substitutions.  For instance, it might be something like:

    logger.info(&quot;Action {} occured on object {}.&quot;, objectA.getAction(), objectB);
If there are more than a few substitutions required then it is something like:

    logger.info(&quot;Action {} occured on object {} with outcome {}.&quot;, 
        new Object[]{objectA.getAction(), objectB, outcome});

My question is: Is there a generic way for me to create a string (and not just a slf4j log message)? Something like:

    String str = someMethod(&quot;Action {} occured on object {}.&quot;, objectA.getAction(), objectB);

or

    String str = someMethod(&quot;Action {} occured on object {} with outcome {}.&quot;, 
        new Object[]{objectA.getAction(), objectB, outcome});

If it is in the standard Java library, what would that &quot;someMethod&quot; be?

Is there a general string substitution function similar to sl4fj?

I think the question is clear enough. Will the `auto` keyword auto-detect const-ness, or always return a non-const type, even if there are eg. two versions of a function (one that returns `const` and the other that doesn&#39;t).

Just for the record, I do use `const auto end = some_container.end()` before my for-loops, but I don&#39;t know if this is necessary or even different from normal `auto`.

does `const auto` have any meaning?

<p>I think the question is clear enough. Will the <code>auto</code> keyword auto-detect const-ness, or always return a non-const type, even if there are eg. two versions of a function (one that returns <code>const</code> and the other that doesn't).</p>
<p>Just for the record, I do use <code>const auto end = some_container.end()</code> before my for-loops, but I don't know if this is necessary or even different from normal <code>auto</code>.</p>


My preprocessor appears to assume that undefined constants are 0 for the purpose of evaluating `#if` conditions.

Can this be relied upon, or do undefined constants give undefined behaviour?

What is the value of an undefined constant used in #if?

Often in C under `gcc`, I will start with the following set of warning flags (painfully assembled from multiple sources):

    -Wall -Wextra -Wformat-nonliteral -Wcast-align -Wpointer-arith -Wbad-function-cast \
    -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations -Winline -Wundef \
    -Wnested-externs -Wcast-qual -Wshadow -Wwrite-strings -Wno-unused-parameter \
    -Wfloat-equal -pedantic -ansi

I will build (at least my debug versions) with this set of warnings and fix everything I possibly can (usually everything), and then only remove flags if they are either not relevant or not fixable (almost never the case).  Sometimes, I&#39;ll also add `-Werror` if I have to step away while compiling.

I&#39;m just picking up C++ (yes, I&#39;m 15 years behind the times), and I&#39;d like to start off on the right foot.

My question is: Does someone have a precompiled similar set of complete warning flags for C++ under `g++`?  (I know many of them will be the same.)

Flags to enable thorough and verbose g++ warnings

Me and my team are developing an application, which involves a back-end written in C++ and involves use of libraries such as OpenCV, MIL, etc.

Now, we need to develop a GUI to interface with this program, such that the GUI displays the images, and the user can interact with the images and annotate / mark the images, and then run the image processing algorithms written in C++ to display results.

For the GUI, i am stuck choosing between WPF and Qt
I personally find WPF to be easier, and more powerful than Qt
I understand that WPF is not portable to Linux, but i am not worried about this too much... 
Also, WPF uses the DirectX technology, which i may have to use to generate some 3-D visualization at a later stage.

Please help me with these points :

2. Can I interface WPF directly with C++ (and not with Visual C# ??)
3. If (Point 1) is not possible, then consider this :
   The code in C++ is going to be big, and involving some libraries too, so can i use C# to call C++ functions 
Would the time invested in learning Qt be lesser than making my unmanaged non-OO C++ code work with WPF ?

(i have a sinking feeling that I&#39;d have to write too much code for interfacing C++ with WPF, which may equal rewriting half of the actual program itself... :-( )


Choosing between WPF/C# and Qt/C++

Arrays of function pointers can be created like so:

    typedef void(*FunctionPointer)();
    FunctionPointer functionPointers[] = {/* Stuff here */};

What is the syntax for creating a function pointer array without using the `typedef`?

What&#39;s the syntax for declaring an array of function pointers without using a separate typedef?

How to make printf to show the values of variables which are of an enum type? For instance:

    typedef enum {Linux, Apple, Windows} OS_type; 
    OS_type myOS = Linux;

and what I need is something like 

    printenum(OS_type, &quot;My OS is %s&quot;, myOS);

which must show a string &quot;Linux&quot;, not an integer.

I suppose, first I have to create a value-indexed array of strings. But I don&#39;t know if that is the most beautiful way to do it. Is it possible at all?

How to convert an enum type variable to a string?

Any function that consists of a return statement only could be declared
`constexpr` and thus will allow to be evaluated at compile time if all
arguments are `constexpr` and only `constexpr` functions are called in its body. **Is there any reason not to declare *any* such function `constexpr` ?**

Example:

      constexpr int sum(int x, int y) { return x + y; }
      constexpr i = 10;
      static_assert(sum(i, 13) == 23, &quot;sum correct&quot;);

**Could anyone provide an example where declaring a function `constexpr`
would do any harm?**


----------


Some initial thoughts:

Even if there should be no good reason for ever declaring a function 
not `constexpr` I could imagine that the `constexpr` keyword has a 
transitional role: its absence in code that does not need compile-time
evaluations would allow compilers that do not implement compile-time 
evaluations still to compile that code (but to fail reliably on code 
that needs them as made explict by using `constexpr`).

But what I do not understand: if there should be no good reason for 
ever declaring a function not `constexpr`, why is not **every** function
in the standard library declared `constexpr`? (You cannot argue
that it is not done yet because there was not sufficient time yet to
do it, because doing it for *all* is a no-brainer -- contrary to deciding for every single function if to make it `constexpr` or not.)
--- I am aware that [N2976](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2976.html)
deliberately not requires cstrs for many standard library types such
as the containers as this would be too limitating for possible 
implementations. Lets exclude them from the argument and just wonder:
once a type in the standard library actually has a `constexpr` cstr, why is not every function operating on it declared `constexpr`?

In most cases you also cannot argue that you may prefer not to declare a function `constexpr` simply because you do not envisage any compile-time usage: because if others evtl. will use your code, they may see such a use that you do not. (But granted for type trait types and stuff alike, of course.)

So I guess there must be a good reason and a good example for deliberately not declaring a function `constexpr`?

(with &quot;every function&quot; I always mean: every function that meets the 
requirements for being `constexpr`, i.e., is defined as a single 
return statement, takes only arguments of types with constexpr 
cstrs and calls only `constexpr` functions. Since C++14, [much more is allowed in the body of such function](https://en.cppreference.com/w/cpp/language/constexpr): e.g., *C++14 constexpr functions may use local variables and loops*, so an even wider class of functions could be declared `constexpr`.) 

The question [Why does `std::forward` discard `constexpr`-ness?](https://stackoverflow.com/questions/5098069/why-discards-stdforward-constexpr-ness) is a special case of this one.


Whyever **not** declare a function to be `constexpr`?

Hi I have files called MyCode.h and MyCode.cpp

In MyCode.h I have declared

    enum MyEnum {Something = 0, SomethingElse = 1};
    
    class MyClass {
    
    MyEnum enumInstance;
    void Foo();
    
    }; 

Then in MyCode.cpp:

    #include &quot;MyCode.h&quot;

    void MyClass::Foo() {
        enumInstance = MyEnum::SomethingElse;
    }


but when compiling with g++ I get the error &#39;MyEnum&#39; is not a class or namespace... 

(works fine in MS VS2010 but not linux g++)

Any ideas?
Thanks
Thomas

My enum is not a class or namespace

In C++11, should the operation of static_assert within a template depend on whether that template has been instantiated or not? For example, with the following code 

    template &lt;int I&gt;
    void sa() { static_assert(0,&quot;Hello.&quot;); }
    
    int main(int argc, char *argv[]) { return 0; }

GCC 4.5.0 will fail the assertion, and produce the &quot;Hello.&quot; message.
The Digital Mars Compiler version 8.42n on the other hand, gives no message.


C++11 static_assert and template instantiation

Ok, this is the first question I&#39;ve asked and I didn&#39;t know you couldn&#39;t answer your own question.

Answer:

March 25, 2011. :-)  I&#39;m not kidding, it&#39;s official.  Well, at least as far as the committee is concerned.

**Update**

Aug. 12, 2011.

The C++ FDIS has officially been approved by ISO in a unanimous vote.  21 of 21 National Bodies voted to APPROVE.

When will C++0x be finished?

I was searching for an implementation of extension methods in c++ and came upon [this comp.std.c++ discussion][1] which mentions that `polymorphic_map` can be used to associated methods with a class, but, the provided link seems to be dead.  Does anyone know what that answer was referring to, or if there is another way to extend classes in a similar manner to extension methods (perhaps through some usage of mixins?).  

I know the canonical C++ solution is to use free functions; this is more out of curiosity than anything else.


  [1]: http://groups.google.com/group/comp.std.c++/browse_thread/thread/c8b7234e249bc107

Extension methods in c++

	sort(mMyClassVector.begin(), mMyClassVector.end(), 
		[](const MyClass &amp; a, const MyClass &amp; b)
	{ 
		return a.mProperty &gt; b.mProperty; 
	});

I&#39;d like to use a lambda function to sort custom classes in place of binding an instance method. However, the code above yields the error:

&gt; error C2564: &#39;const char *&#39; : a function-style conversion to a built-in type can only take one argument

It works fine with `boost::bind(&amp;MyApp::myMethod, this, _1, _2)`.

How to sort with a lambda?

I tried to use the `operator[]` access the element in a `const map`, but this method failed. I also tried to use `at()` to do the same thing. It worked this time. However, I could not find any reference about using `at()` to access element in a `const map`. Is `at()` a newly added function in `map`? Where can I find more info about this? Thank you very much!

An example could be the following:

    #include &lt;iostream&gt;
    #include &lt;map&gt;
    
    using namespace std;
    
    int main()
    {
            map&lt;int, char&gt; A;
            A[1] = &#39;b&#39;;
            A[3] = &#39;c&#39;;
    
            const map&lt;int, char&gt; B = A;

            cout &lt;&lt; B.at(3) &lt;&lt; endl; // it works
            cout &lt;&lt; B[3] &lt;&lt; endl;  // it does not work
    
    }


For using &quot;B[3]&quot;, it returned the following errors during compiling:

&gt; t01.cpp:14: error: passing ‘const
&gt; std::map&lt;int, char, std::less&lt;int&gt;,
&gt; std::allocator&lt;std::pair&lt;const int,
&gt; char&gt; &gt; &gt;’ as ‘this’ argument of ‘_Tp&amp;
&gt; std::map&lt;_Key, _Tp, _Compare,
&gt; _Alloc&gt;::operator[](const _Key&amp;) [with _Key = int, _Tp = char, _Compare = std::less&lt;int&gt;, _Alloc =
&gt; std::allocator&lt;std::pair&lt;const int,
&gt; char&gt; &gt;]’ discards qualifiers

The compiler used is g++ 4.2.1

Const map element access

Is it possible to write something similar to the following?

    public const string[] Titles = { &quot;German&quot;, &quot;Spanish&quot;, &quot;Corrects&quot;, &quot;Wrongs&quot; };


Declare a const array

This question may be naive, but:

 - is there `const` keyword in C?
 - since which version?
 - are there any semantic and/or syntactic differences between `const` in C and C++?    




Content Type	Original Author	Original Content on Stackoverflow
Question	rubenvb	View Question on Stackoverflow
Solution 1 - C++	antonakos	View Answer on Stackoverflow
Solution 2 - C++	Benoit	View Answer on Stackoverflow
Solution 3 - C++	Kirill V. Lyadvinsky	View Answer on Stackoverflow
Solution 4 - C++	BJovke	View Answer on Stackoverflow

does `const auto` have any meaning?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Is there a general string substitution function similar to sl4fj?

Can I use collection initializers with a NameValueCollection?

Attributions