Yes.  It is called an &quot;[alias template](http://en.cppreference.com/w/cpp/language/type_alias),&quot; and it&#39;s a new feature in C++11.

    template&lt;typename T&gt;
    using MyVector = std::vector&lt;T, MyCustomAllocator&lt;T&gt;&gt;;

Usage would then be exactly as you expect:

    MyVector&lt;int&gt; x; // same as: std::vector&lt;int, MyCustomAllocator&lt;int&gt;&gt;

GCC has supported it since 4.7, Clang has it since 3.0, and MSVC has it in 2013 SP4.


  [1]: http://gcc.gnu.org/bugzilla/attachment.cgi?id=21341

In C++03 you can inherit from a class (publically or privately) to do so. 

    template &lt;typename T&gt;
    class MyVector : public std::vector&lt;T, MyCustomAllocator&lt;T&gt; &gt; {};

You need to do a bit more work (Specifically, copy constructors, assignment operators) but it&#39;s quite doable.

I am implementing node to PDF using Drupal and tcpdf. In such case I am suppose to use this `&lt;&lt;&lt;EOD` tag. If I don&#39;t use it, it throws error. I can&#39;t exactly get the purpose of `&lt;&lt;&lt;EOD`. 

Could anybody please explain the concept of this?


    $html = &lt;&lt;&lt;EOD
            &lt;tr&gt;
              &lt;td&gt;TEST&lt;/td&gt;
            &lt;/tr&gt;
    EOD;



What is the use of &lt;&lt;&lt;EOD in PHP?

It is very easy to bind `Button`s in WPF apps to `Command`s in a `VIEWMODEL` class. I&#39;d like to achieve a similar binding for a `TextBox`.

I have a `TextBox` and I need to bind it to a `Command` that fires up when I hit &lt;kbd&gt;Enter&lt;/kbd&gt; while the `TextBox` is focused. Currently, I&#39;m using the following handler for the `KeyUp` event, but it looks ugly...
and I can&#39;t put it in my `VIEWMODEL` class.

    private void TextBox_KeyUp(object sender, KeyEventArgs e)
    {
        if (e.Key == System.Windows.Input.Key.Enter)
        {
            // your event handler here
            e.Handled = true;
            MessageBox.Show(&quot;Enter Key is pressed!&quot;);
        }
    }

Is there a better way to do this?

Command for WPF TextBox that fires up when we hit Enter Key

How should I `typedef` a `template class` ? Something like:

    typedef std::vector myVector;  // &lt;--- compiler error
I know of 2 ways:

    (1) #define myVector std::vector // not so good
    (2) template&lt;typename T&gt;
        struct myVector { typedef std::vector&lt;T&gt; type; }; // verbose
Do we have anything better in C++0x ?


How to typedef a template class?

How should I <code>typedef</code> a <code>template class</code> ? Something like:
<pre><code class="hljs language-c">typedef std::vector myVector; // &#x3C;--- compiler error
</code></pre>
I know of 2 ways:
<pre><code class="hljs language-arduino">(1) #define myVector std::vector // not so good
(2) template&#x3C;typename T>
 struct myVector { typedef std::vector&#x3C;T> type; }; // verbose
</code></pre>
Do we have anything better in C++0x ?

I need some pointers/advice on how to automatically generate CMakeLists.txt files for CMake. Does anyone know of any existing generators? I&#39;ve checked the ones listed in the [CMake Wiki][1] but unfortunately they are not suitable for me. 

I already have a basic Python script which traverses my project&#39;s directory structure and generates the required files but it&#39;s really &quot;dumb&quot; right now. I would like to augment it to take into account for example the different platforms I&#39;m building for, the compiler\cross-compiler I&#39;m using or different versions of the libraries dependencies I might have. I don&#39;t have much\expert experience with CMake and an example I could base my work or an already working generator could be of great help.


  [1]: http://www.cmake.org/Wiki/CMake#Basic_CMakeLists.txt_from-scratch-generator

How to generate CMakeLists.txt?

Suppose I want to write a generic function `void f&lt;T&gt;()`, which does one thing if `T` is a POD type and another thing if `T` is non-POD (or any other arbitrary predicate).

One way to achieve this would be to use a tag-dispatch pattern like the standard library does with iterator categories:

    template &lt;bool&gt; struct podness {};
    typedef podness&lt;true&gt; pod_tag;
    typedef podness&lt;false&gt; non_pod_tag;

    template &lt;typename T&gt; void f2(T, pod_tag) { /* POD */ }
    template &lt;typename T&gt; void f2(T, non_pod_tag) { /* non-POD */ }

    template &lt;typename T&gt;
    void f(T x)
    {
        // Dispatch to f2 based on tag.
        f2(x, podness&lt;std::is_pod&lt;T&gt;::value&gt;());
    }

An alternative would be to use static member function of partially specialised types:

    template &lt;typename T, bool&gt; struct f2;

    template &lt;typename T&gt;
    struct f2&lt;T, true&gt; { static void f(T) { /* POD */ } };
  
    template &lt;typename T&gt;
    struct f2&lt;T, false&gt; { static void f(T) { /* non-POD */ } };

    template &lt;typename T&gt;
    void f(T x)
    {
        // Select the correct partially specialised type.
        f2&lt;T, std::is_pod&lt;T&gt;::value&gt;::f(x);
    }

What are the pros and cons of using one method over the other? Which would you recommend?


Tag dispatch versus static methods on partially specialised classes

At a job interview I was asked the question &quot;In C++ how do you access a variable faster, though the normal variable identifier or though a pointer&quot;. I must say I did not have a good technical answer to the question so I took a wild guess.

*I said that access time will probably be that same as normal variable/identifier is a pointer to the memory address where the value is stored, just like a pointer. In other words, that in terms of speed they both have the same performance, and that pointers are only different because we can specify the memory address we want them to point to.*

The interviewer did not seem very convinced/satisfied with my answer (although he did not say anything, just carried on asking something else), therefore I though to come and ask SO&#39;ers wether my answer was accurate, and if not why (from a theory  and technical POV).



Pointer vs Variable speed in C++

Why do objects of the same class have access to each other&#39;s private data?

    class TrivialClass {
    public: 
      TrivialClass(const std::string&amp; data) :
        mData(data) {};

      const std::string&amp; getData(const TrivialClass&amp; rhs) const {
        return rhs.mData;
      };
    
    private:
      std::string mData;
    };
    
    int main() {
      TrivialClass a(&quot;fish&quot;);
      TrivialClass b(&quot;heads&quot;);

      std::cout &lt;&lt; &quot;b via a = &quot; &lt;&lt; a.getData(b) &lt;&lt; std::endl;
      return 0;
    }


This codes works.  It is perfectly possible for object a to access private data from object b and return it.  Why should this be so?  I would think that private data is private.  (I started out by trying to understand copy constructors in the pimpl idiom, but then I discovered that I didn&#39;t even understand this simple situation.)

Why do objects of the same class have access to each other&#39;s private data?

Today, I discovered a rather interesting thing about either `g++` or `nm`...constructor definitions appear to have two entries in libraries.

I have a header `thing.hpp`:

    class Thing
    {
        Thing();
        
        Thing(int x);
        
        void foo();
    };

And `thing.cpp`:

    #include &quot;thing.hpp&quot;
    
    Thing::Thing()
    { }
    
    Thing::Thing(int x)
    { }
    
    void Thing::foo()
    { }

I compile this with:

    g++ thing.cpp -c -o libthing.a

Then, I run `nm` on it:

    %&gt; nm -gC libthing.a
    0000000000000030 T Thing::foo()
    0000000000000022 T Thing::Thing(int)
    000000000000000a T Thing::Thing()
    0000000000000014 T Thing::Thing(int)
    0000000000000000 T Thing::Thing()
                     U __gxx_personality_v0

As you can see, both of the constructors for `Thing` are listed with two entries in the generated static library.  My `g++` is 4.4.3, but the same behavior happens in `clang`, so it isn&#39;t just a `gcc` issue.

This doesn&#39;t cause any apparent problems, but I was wondering:

 - Why are defined constructors listed twice?
 - Why doesn&#39;t this cause &quot;multiple definition of symbol __&quot; problems?

---

**EDIT**: For Carl, the output without the `C` argument:

    %&gt; nm -g libthing.a
    0000000000000030 T _ZN5Thing3fooEv
    0000000000000022 T _ZN5ThingC1Ei
    000000000000000a T _ZN5ThingC1Ev
    0000000000000014 T _ZN5ThingC2Ei
    0000000000000000 T _ZN5ThingC2Ev
                     U __gxx_personality_v0

As you can see...the same function is generating multiple symbols, which is still quite curious.

And while we&#39;re at it, here is a section of generated assembly:

    .globl _ZN5ThingC2Ev
            .type   _ZN5ThingC2Ev, @function
    _ZN5ThingC2Ev:
    .LFB1:
            .cfi_startproc
            .cfi_personality 0x3,__gxx_personality_v0
            pushq   %rbp
            .cfi_def_cfa_offset 16
            movq    %rsp, %rbp
            .cfi_offset 6, -16
            .cfi_def_cfa_register 6
            movq    %rdi, -8(%rbp)
            leave
            ret
            .cfi_endproc
    .LFE1:
            .size   _ZN5ThingC2Ev, .-_ZN5ThingC2Ev
            .align 2
    .globl _ZN5ThingC1Ev
            .type   _ZN5ThingC1Ev, @function
    _ZN5ThingC1Ev:
    .LFB2:
            .cfi_startproc
            .cfi_personality 0x3,__gxx_personality_v0
            pushq   %rbp
            .cfi_def_cfa_offset 16
            movq    %rsp, %rbp
            .cfi_offset 6, -16
            .cfi_def_cfa_register 6
            movq    %rdi, -8(%rbp)
            leave
            ret
            .cfi_endproc

So the generated code is...well...the same.

---

**EDIT**: To see what constructor actually gets called, I changed `Thing::foo()` to this:

    void Thing::foo()
    {
        Thing t;
    }

The generated assembly is:

    .globl _ZN5Thing3fooEv
            .type   _ZN5Thing3fooEv, @function
    _ZN5Thing3fooEv:
    .LFB550:
            .cfi_startproc
            .cfi_personality 0x3,__gxx_personality_v0
            pushq   %rbp
            .cfi_def_cfa_offset 16
            movq    %rsp, %rbp
            .cfi_offset 6, -16
            .cfi_def_cfa_register 6
            subq    $48, %rsp
            movq    %rdi, -40(%rbp)
            leaq    -32(%rbp), %rax
            movq    %rax, %rdi
            call    _ZN5ThingC1Ev
            leaq    -32(%rbp), %rax
            movq    %rax, %rdi
            call    _ZN5ThingD1Ev
            leave
            ret
            .cfi_endproc

So it is invoking the complete object constructor.

Dual emission of constructor symbols

I&#39;m working with Symfony 2 on a site which having 2 languages,
and I want to change patterns of my routes depending on user locale language !

Example:

    user_login_en:
        pattern:  /en/user/login.html
        defaults: { _controller: SfErrorsAppBundle:User:login, _locale: en }
    
    user_login_fr:
        pattern:  /fr/utilisateur/connexion.html
        defaults: { _controller: SfErrorsAppBundle:User:login, _locale: fr}


Inside a template, this is not difficult, i just have to pass the $this-&gt;get(&#39;session&#39;)-&gt;getLocale() from the controller to the template...

To work, I have to call my routes:

    $router-&gt;generate(&#39;user_login_&#39;.$locale, array());

But  inside my layouts, I have of course a menu, and sidebars, which have links... So I want to get the locale variable to use it ! So my question is simple: how to get this variable inside a &quot;layout&quot; template ? Otherwise, have you got any idea to change the pattern depending on the language ?

The reasons are that I want beautiful routes for all users, whether they&#39;re english or french... And also for a SEO reason !

How to get the _locale variable inside in a Symfony layout?

To me, C++ template used the idea of duck typing, is this right? Does it mean all generic types referenced in template class or method are duck type?

What&#39;s the relationship between C++ template and duck typing?

I am trying to get a simple example to work to understand how to use `std::enable_if`. After I read [this answer][1], I thought it shouldn&#39;t be too hard to come up with a simple example. I want to use `std::enable_if` to choose between two member-functions and allow only one of them to be used.

Unfortunately, the following doesn&#39;t compile with gcc 4.7 and after hours and hours of trying I am asking you guys what my mistake is.

    #include &lt;utility&gt;
    #include &lt;iostream&gt;
    
    template&lt; class T &gt;
    class Y {
    
        public:
            template &lt; typename = typename std::enable_if&lt; true &gt;::type &gt;
            T foo() {
                return 10;
            }
            template &lt; typename = typename std::enable_if&lt; false &gt;::type &gt;
            T foo() {
                return 10;
            }
    
    };
    
    
    int main() {
        Y&lt; double &gt; y;
    
        std::cout &lt;&lt; y.foo() &lt;&lt; std::endl;
    }

gcc reports the following problems:

    % LANG=C make CXXFLAGS=&quot;-std=c++0x&quot; enable_if
    g++ -std=c++0x    enable_if.cpp   -o enable_if
    enable_if.cpp:12:65: error: `type&#39; in `struct std::enable_if&lt;false&gt;&#39; does not name a type
    enable_if.cpp:13:15: error: `template&lt;class T&gt; template&lt;class&gt; T Y::foo()&#39; cannot be overloaded
    enable_if.cpp:9:15: error: with `template&lt;class T&gt; template&lt;class&gt; T Y::foo()&#39;


Why doesn&#39;t g++ delete the wrong instantiation for the second member function? According to the standard, `std::enable_if&lt; bool, T = void &gt;::type` only exists when the boolean template parameter is true. But why doesn&#39;t g++ consider this as SFINAE? I think that the overloading error message comes from the problem that g++ doesn&#39;t delete the second member function and believes that this should be an overload.


  [1]: https://stackoverflow.com/questions/6627651/enable-if-method-specialization/6627748#6627748



std::enable_if to conditionally compile a member function

Is there any way in C++ define a type that is big enough to hold at most a specific number, presumably using some clever template code. For example I want to be able to write :-

    Integer&lt;10000&gt;::type dataItem;

And have that type resolve to the smallest type that is big enough to hold the specified value?

Background: I need to generate some variable defintions using a script from an external data file. I guess I could make the script look at the values and then use `uint8_t`, `uint16_t`, `uint32_t`, etc. depending on the value, but it seems more _elegant_ to build the size into the generated C++ code.

I can&#39;t see any way to make a template that can do this, but knowing C++ templates, I&#39;m sure there is a way. Any ideas?


Automatically pick a variable type big enough to hold a specified number

So I want to do something like follows:

    {% if age &gt; 18 %}
        {% with patient as p %}
    {% else %}
        {% with patient.parent as p %}
        ...
    {% endwith %}
    {% endif %}

But Django is telling me that I need another {% endwith %} tag.  Is there any way to rearrange the withs to make this work, or is the syntactic analyzer purposefully carefree in regards to this sort of thing?

Maybe I&#39;m going about this the wrong way.  Is there some sort of best practice when it comes to something like this?

Django {% with %} tags within {% if %} {% else %} tags?

When we have,

    struct E { enum E_ { HELLO }; }; // &#39;E&#39; is inheritable
then why do we need,

    enum class E { HELLO };  // &#39;E&#39; is not inheritable
IMO 2nd version doesn&#39;t offer more features than the 1st. I don&#39;t think that `enum class` is introduced just to save 2 curly braces `{};`! Am I missing any important aspect ?

As a minor question, is there any difference between `enum class` and `enum struct` other than syntax (because both have `public` access specifier) ?

Do we really need &quot;enum class&quot; in C++11?

Currently, I can only do ranged based loops with this:

    for (auto&amp; value : values)

But sometimes I need an iterator to the value, instead of a reference (For whatever reason). Is there any method without having to go through the whole vector comparing values?

Need iterator when using ranged-based for loops

Container requirements have changed from C++03 to C++11. While C++03 had blanket requirements (e.g. copy constructibility and assignability for vector), C++11 defines fine-grained requirements on each container operation (section 23.2).

As a result, you can e.g. store a type that is copy-constructible but not assignable - such as a structure with a const member - in a vector as long as you only perform certain operations that do not require assignment (construction and `push_back` are such operations; `insert` is not).

What I&#39;m wondering is: does this mean the standard now allows `vector&lt;const T&gt;`? I don&#39;t see any reason it shouldn&#39;t - `const T`, just like a structure with a const member, is a type that is copy constructible but not assignable - but I may have missed something.

(Part of what makes me think I may have missed something, is that gcc trunk crashes and burns if you try to instantiate `vector&lt;const T&gt;`, but it&#39;s fine with `vector&lt;T&gt;` where T has a const member).

Does C++11 allow vector&lt;const T&gt;?

The common example for C++11 range-based for() loops is always something simple like this:

    std::vector&lt;int&gt; numbers = { 1, 2, 3, 4, 5, 6, 7 };
    for ( auto xyz : numbers )
    {
         std::cout &lt;&lt; xyz &lt;&lt; std::endl;
    }

In which case `xyz` is an `int`.  But, what happens when we have something like a map?  What is the type of the variable in this example:

    std::map&lt; foo, bar &gt; testing = { /*...blah...*/ };
    for ( auto abc : testing )
    {
        std::cout &lt;&lt; abc &lt;&lt; std::endl;         // ? should this give a foo? a bar?
        std::cout &lt;&lt; abc-&gt;first &lt;&lt; std::endl;  // ? or is abc an iterator?
    }

When the container being traversed is something simple, it looks like range-based for() loops will give us each item, not an iterator.  Which is nice...if it was iterator, first thing we&#39;d always have to do is to dereference it anyway.

But I&#39;m confused as to what to expect when it comes to things like maps and multimaps.

(I&#39;m still on g++ 4.4, while range-based loops are in g++ 4.6+, so I haven&#39;t had the chance to try it yet.)

How to use range-based for() loop with std::map?

I came across a new use of the keyword **typedef** in C++.

What does this typedef statement mean ?

    int typedef foo;

Unusual typedef use in C++

I would like a standard reference why the following code triggers a compliance warning in C (tested with `gcc -pedantic`; &quot;typedef redefinition&quot;), but is fine in C++ (`g++ -pedantic`):

    typedef struct Foo Foo;
    typedef struct Foo Foo;
    
    int main() { return 0; }

Why can I not define a `typedef` repeatedly in C?

(This has practical implications for the header structuring of a [C project](http://sc2.svn.sourceforge.net/viewvc/sc2/trunk/sc2/src/libs/resource/index.h?revision=3704&amp;view=markup).)

Repeated typedefs - invalid in C but valid in C++?

I know that in C++11 we can now use `using` to write type alias, like `typedef`s:

    typedef int MyInt;

Is, from what I understand, equivalent to:

    using MyInt = int;

And that new syntax emerged from the effort to have a way to express &quot;template typedef&quot;:

    template&lt; class T &gt; using MyType = AnotherType&lt; T, MyAllocatorType &gt;;

But, with the first two non-template examples, are there any other subtle differences in the standard? For example, `typedef`s do aliasing in a &quot;weak&quot; way. That is it does not create a new type but only a new name (conversions are implicit between those names).

Is it the same with `using` or does it generate a new type? Are there any differences?

What is the difference between &#39;typedef&#39; and &#39;using&#39; in C++11?

I have read the description, and I understand that it is a function-type alias.

- A typedef, or function-type alias, gives a function type a name that you can use when declaring fields and return types. A typedef retains type information when a function type is assigned to a variable.

- http://www.dartlang.org/docs/spec/latest/dart-language-specification.html#kix.yyd520hand9j

But how do I use it? Why declaring fields with a function-type? When do I use it? What problem does it solve? 

I think I need one or two real code examples.

What are function typedefs / function-type aliases in Dart?

I&#39;d like to write this

    typedef void (*FunctionPtr)();

using `using`. How would I do that?

Content Type	Original Author	Original Content on Stackoverflow
Question	iammilind	View Question on Stackoverflow
Solution 1 - C++	Travis Gockel	View Answer on Stackoverflow
Solution 2 - C++	dascandy	View Answer on Stackoverflow

How to typedef a template class?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Command for WPF TextBox that fires up when we hit Enter Key

What is the use of <<<EOD in PHP?

Attributions