typedef is defining a new type for use in your code, like a shorthand.

    typedef typename _MyBase::value_type value_type;
    value_type v;
    //use v

typename here is letting the compiler know that `value_type` is a type and not a static member of `_MyBase`.

the `::` is the scope of the type. It is kind of like &quot;is in&quot; so `value_type` &quot;is in&quot; `_MyBase`. or can also be thought of as contains.

the `typename` is saying that `_Mybase::value_type` is the name of type so the `typedef` can reley on that fact.

I&#39;m trying to get a custom legend for a ggplot with data coming from two separate data frames. See below for a minimum reproducible example.

What I&#39;m trying to accomplish is to have a legend describing the ribbon fill, the black line, and the red line.

    require(ggplot2)
    x=seq(1,10,length=100)
    data=data.frame(x,dnorm(x,mean=6.5,sd=1))
    names(data)=c(&#39;x&#39;,&#39;new.data&#39;)
    x.ribbon=seq(1,10,length=20)
    ribbon=data.frame(x.ribbon,
                      dnorm(x.ribbon,mean=5,sd=1)+.01,
                      dnorm(x.ribbon,mean=5,sd=1)-.01,
                      dnorm(x.ribbon,mean=5,sd=1))
    names(ribbon)=c(&#39;x.ribbon&#39;,&#39;max&#39;,&#39;min&#39;,&#39;avg&#39;)
    ggplot()+geom_ribbon(data=ribbon,aes(ymin=min,ymax=max,x=x.ribbon),fill=&#39;lightgreen&#39;)+
      geom_line(data=ribbon,aes(x=x.ribbon,y=avg),color=&#39;black&#39;)+
      geom_line(data=data,aes(x=x,y=new.data),color=&#39;red&#39;)+
      xlab(&#39;x&#39;)+ylab(&#39;density&#39;)

![enter image description here][1]


  [1]: http://i.stack.imgur.com/x01Tq.png

Custom legend for multiple layer ggplot

I am learning python (python 3) and I can copy 1 file to a new directory
by doing this

    import shutil 
    shutil.copyfile(&#39;C:/test/test.txt&#39;, &#39;C:/lol/test.txt&#39;)

What I am now trying to do is to copy all *.txt files from C:/ to C:/test

*.txt is a wildcard to search for all the text files on my hard drive

python copy files by wildcards

In a C++ header file, I am seeing this code:

    typedef typename _Mybase::value_type value_type;


Now, as I understand, quoting from &#171; *C++ the Complete Reference* &#187; by Schildt. `typename` can be substituted by keyword class, the second use of `typename` is to inform the compiler that a name used in a template declaration is a type name rather than an object name. 

Similarly, you can define new data type names by using the keyword `typedef`. You are not
actually creating a new data type, but rather defining a new name for an existing
type. 

However, can you explain exactly what is the meaning of the above line of code, where `typedef` and `typename` are combined together. And what does the &quot;`::`&quot; in the statement imply?




C++ - meaning of a statement combining typedef and typename

In a C++ header file, I am seeing this code:
<pre><code class="hljs language-arduino">typedef typename _Mybase::value_type value_type;
</code></pre>
Now, as I understand, quoting from « C++ the Complete Reference » by Schildt. <code>typename</code> can be substituted by keyword class, the second use of <code>typename</code> is to inform the compiler that a name used in a template declaration is a type name rather than an object name.
Similarly, you can define new data type names by using the keyword <code>typedef</code>. You are not
actually creating a new data type, but rather defining a new name for an existing
type.
However, can you explain exactly what is the meaning of the above line of code, where <code>typedef</code> and <code>typename</code> are combined together. And what does the "<code>::</code>" in the statement imply?

I just reinstalled QtCreator, created new project (*Qt Application*) an got this after compilation: 

    /usr/bin/ld: **cannot find -lGL**
    collect2: error: ld returned 1 exit status
    make: *** [untitled1] Error 1
    18:07:41: The process &quot;/usr/bin/make&quot; exited with code 2.
    Error while building/deploying project untitled1 (kit: Desktop Qt 5.1.0 GCC 32bit)
    When executing step &#39;Make&#39;

(*Project is empty, I did&#39;n commit any changes*)

&gt; Qt Creator 2.7.2  
Based on Qt 5.1.0 (32 bit)  
Ubuntu 13.04

How do I solve this problem?

Qt: can&#39;t find -lGL error

I&#39;m under osx 10.8.4 and have installed gdb 7.5.1 with homebrew (motivation get a new gdb with  new features such as --with-python etc... )

Long story short when I run debug within a c++ Eclipse project I get :


    Error in final launch sequence
    Failed to execute MI command:
    -exec-run
    Error message from debugger back end:
    Unable to find Mach task port for process-id 46234: (os/kern) failure (0x5).
     (please check gdb is codesigned - see taskgated(8))
    Unable to find Mach task port for process-id 46234: (os/kern) failure (0x5).
     (please check gdb is codesigned - see taskgated(8))

I have followed various suggestions for code signing

- https://sourceware.org/gdb/wiki/BuildingOnDarwin
- partly http://www.noktec.be/archives/1251 with various adjusts

So I did:

1. Set up the certificate
2. Sign the gdb -&gt; codesign -s gdb-cert /usr/local/bin/gdb

When I re-run debugging in Eclipse I get same error as above &quot;(please check gdb is codesigned - see taskgated(8))&quot;.

If I set back the gdb to the older gdb (in the gdb preferences of Eclipse) /usr/libexec/gdb/gdb-i386-apple-darwin the debugging runs as expected.

Any solutions / hints out there ?

Thx

Pelle

&quot;please check gdb is codesigned - see taskgated(8)&quot; - How to get gdb installed with homebrew code signed?

Playing around with Lambdas I found an interesting behaviour that I do not fully understand.

Supose I have a `struct Overload` that derives from 2 template parameters, and has a `using F1::operator();` clause.

Now if I derive from two functors I can only access the operator() of F1 (as I would expect)

If I derive from two Lambda Functions this is no longer true: I can access the operator() from F2 too.

    #include &lt;iostream&gt;
    
    // I compiled with g++ (GCC) 4.7.2 20121109 (Red Hat 4.7.2-8)
    //
    // g++ -Wall -std=c++11 -g main.cc
    // g++ -Wall -std=c++11 -DFUNCTOR -g main.cc
    // 
    // or clang clang version 3.3 (tags/RELEASE_33/rc2)
    // 
    // clang++ -Wall -std=c++11 -g main.cc
    // clang++ -Wall -std=c++11 -DFUNCTOR -g main.cc
    // 
    // on a Linux localhost.localdomain 3.9.6-200.fc18.i686 #1 SMP Thu Jun 13 
    // 19:29:40 UTC 2013 i686 i686 i386 GNU/Linux box
    
     
    struct Functor1
    {
        void operator()() { std::cout &lt;&lt; &quot;Functor1::operator()()\n&quot;; }
    };
    
    struct Functor2
    {
        void operator()(int) { std::cout &lt;&lt; &quot;Functor2::operator()(int)\n&quot;; }
    };
    
    template &lt;typename F1, typename F2&gt;
    struct Overload : public F1, public F2
    {
        Overload()
            : F1()
            , F2() {}
    
        Overload(F1 x1, F2 x2)
            : F1(x1)
            , F2(x2) {}
    
        using F1::operator(); 
    };
    
    template &lt;typename F1, typename F2&gt;
    auto get(F1 x1, F2 x2) -&gt; Overload&lt;F1, F2&gt;
    {
       return Overload&lt;F1, F2&gt;(x1, x2);
    }
    
    
    int main(int argc, char *argv[])
    {
        auto f = get(Functor1(), Functor2());
    
        f();
    #ifdef FUNCTOR
        f(2); // this one doesn&#39;t work IMHO correctly
    #endif
    
        auto f1 = get(
                      []() { std::cout &lt;&lt; &quot;lambda1::operator()()\n&quot;; },
                      [](int) { std::cout &lt;&lt; &quot;lambda2::operator()(int)\n&quot;; }
                      );
        f1();
        f1(2); // this one works but I don&#39;t know why
    
    
      return 0;
    }

The standard states that:
&gt; The type of the lambda-expression (which is also the type of the closure object) 
&gt; is a unique, unnamed non- union class type

So every Lambda&#39;s types should be unique.

I cannot explain why this is so: can anyone shed some light on this please?

Lambda functions as base classes

I need to store a 128 bits long [UUID][1] in a variable. Is there a 128-bit datatype in C++? I do not need arithmetic operations, I just want to easily store and read the value very fast.

A new feature from C++11 would be fine, too.


  [1]: http://en.wikipedia.org/wiki/UUID

Is there a 128 bit integer in C++?

According to the sources I have found, a *lambda expression* is essentially implemented by the compiler creating a class with overloaded function call operator and the referenced variables as members. This suggests that the size of lambda expressions varies, and given enough references variables that size can be *arbitrarily large*.

An `std::function` should have a *fixed size*, but it must be able to wrap any kind of callables, including any lambdas of the same kind. How is it implemented? If `std::function` internally uses a pointer to its target, then what happens, when the `std::function` instance is copied or moved? Are there any heap allocations involved?

How is std::function implemented?

I am a beginner in C programming and I know the difference between `struct` type declaration and `typedef` struct declaration. I came across to know an answer saying that if we define a `struct` like:

    typedef struct { 
        some members;
    } struct_name;

Then it will be like providing an alias to an anonymous struct (as it is not having a tag name). So it can&#39;t be used for forward declaration. I don&#39;t know what the *forward declaration* means.

Also, I wanted to know that for the following code:
        
    typedef struct NAME { 
        some members;
    } struct_alias;

Is there any difference between `NAME` and `struct_alias`? Or are both equal as 
`struct_alias` is an alias of  struct NAME ? 

Furthermore, can we declare a variable of type `struct NAME` like these:

    struct_alias variable1;

and/or like:

    struct NAME variable2;

or like:

    NAME variable3; 


What is &#39;forward declaration&#39; and the difference between &#39;typedef struct X&#39; and &#39;struct X&#39;?

Consider:

    #define MAXROW 20
    #define MAXCOL 60
    typedef State Grid[MAXROW+2] [MAXCOL+2]
    typedef enum state {DEAD,ALIVE} State

How do I use `typedef` and `typedef enum` in C? What does this part of the code do?


How do I use typedef and typedef enum in C?

I am writing a program and I would really prefer to write in C++, however, I&#39;m required to include a C header that redefines bool:  

    # define false 0
    # define true  1
    typedef int bool;

The obvious solution would be to edit the header to say:

    #ifndef __cplusplus
    # define false 0
    # define true  1
    typedef int bool;
    #endif

but, alas, since the library is read-only I cannot.

Is there a way I can tell gcc to ignore this typedef? Or, can I write most functions in C++ and then make a C wrapper for the two? Or, should I suck it up and write the thing in C?

Can I mimic a C header that redefines bool in C++?

In a C++ reference page they provide some typedef examples and I&#39;m trying to understand what they mean.
    
    // simple typedef
    typedef unsigned long mylong;
     
     
    // more complicated typedef
    typedef int int_t, *intp_t, (&amp;fp)(int, mylong), arr_t[10];

So the simple typedef (the first declaration) I understand.

But what are they declaring with the second one (repeated below)?

    typedef int int_t, *intp_t, (&amp;fp)(int, ulong), arr_t[10];

Particularly what does `(&amp;fp)(int, mylong)` mean?

What does this typedef statement mean?

If I require a custom type in Swift, that I could `typedef`, how do I do it? (Something like a closure syntax typedef)

How do I declare typedef in Swift

This bit of code compiled in C++20 (using gcc 10.1) without using the ```typename``` keyword before the dependent type ```std::vector&lt;T&gt;::iterator```. Why does it compile?
```
#include &lt;vector&gt;

template&lt;typename T&gt;
std::vector&lt;T&gt;::iterator // Why does this not require &quot;typename&quot; before it?
f() { return {}; }

int main() {
    auto fptr = &amp;f&lt;int&gt;;
}
```

[code playground](https://godbolt.org/z/WhSs53)

Content Type	Original Author	Original Content on Stackoverflow
Question	Arvind	View Question on Stackoverflow
Solution 1 - C++	pippin1289	View Answer on Stackoverflow
Solution 2 - C++	Paul Evans	View Answer on Stackoverflow

C++ - meaning of a statement combining typedef and typename

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

python copy files by wildcards

Custom legend for multiple layer ggplot

Attributions