It&#39;s the same as

&lt;!-- language: lang-c --&gt;

    typedef int foo;

i.e. it defines `foo` to be the type `int`.  While the grammar allows to swap `typedef` and `int` in this case, you usually would not do this because it impairs readability.

`typedef` is a decl-specifier, so it has the same syntax rules as `const` or `static`. It can be moved about like that and will mean the same thing.

After the installation of my ant in my windows 7 . In cmd i typed **ant -v** it&#39;s given the ant version but it says the following also. 

    Buildfile: build.xml does not exist!
    Build failed

What&#39;s the problem in the system. How i can rectify this issue? 

ant build.xml file doesn&#39;t exist

Let&#39;s say I have a project with this structure:

    MyLibrary\
      MyLibrary.sln
      MyLibrary.Core\
        MyLibrary.Core.csproj
      MyLibrary.Extensions\
        MyLibrary.Extensions.csproj
      MyLibrary.Tests\
        MyLibrary.Tests.csproj

I want to create a single NuGet package which packages MyLibrary.Core.dll and MyLibrary.Extensions.dll.  I can&#39;t seem to figure out how to get NuGet to do this.  I&#39;ve tried building a spec file manually and I&#39;ve tried building one using &quot;nuget spec MyLibrary.Core.csproj&quot;.  I&#39;ve tried adding all of the DLLs to a lib/ folder which I understand to be the convention-based mechanism for adding DLLs to the package.  In every case I can get the MyLibary.Core.dll to get into the package but the MyLibrary.Extensions.dll does not end up packaged along with it.

TLDR: What is the best practice for creating a NuGet package with multiple projects / assemblies?  Is there a tutorial out there that focuses on this?  The tutorials I&#39;ve found all focus on simple single-project demos.

Create nuget package with multiple DLLs

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 came across a new use of the keyword typedef in C++.
What does this typedef statement mean ?
<pre><code class="hljs language-arduino">int typedef foo;
</code></pre>

I just found myself not fully understanding the logic of `std::move()`. 

At first, I googled it but seems like there are only documents about how to use `std::move()`, not how its structure works.

I mean, I know what the template member function is but when I look into `std::move()` definition in VS2010, it is still confusing.

the definition of std::move() goes below.

    template&lt;class _Ty&gt; inline
	typename tr1::_Remove_reference&lt;_Ty&gt;::_Type&amp;&amp;
		move(_Ty&amp;&amp; _Arg)
	    {	// forward _Arg as movable
	        return ((typename tr1::_Remove_reference&lt;_Ty&gt;::_Type&amp;&amp;)_Arg);
	    }



What is weird first to me is the parameter, (_Ty&amp;&amp; _Arg), because when I call the function like you see below, 
    
    // main()
    Object obj1;
    Object obj2 = std::move(obj1);

it basically equals to

    // std::move()
    _Ty&amp;&amp; _Arg = Obj1;

But as you already know, you can not directly link a LValue to a RValue reference, which makes me think that it should be like this.

    _Ty&amp;&amp; _Arg = (Object&amp;&amp;)obj1;

However, this is absurd because std::move() must work for all the values.

So I guess to fully understand how this works, I should take a look at these structs too.

    template&lt;class _Ty&gt;
	struct _Remove_reference
	{	// remove reference
    	typedef _Ty _Type;
	};

    template&lt;class _Ty&gt;
	struct _Remove_reference&lt;_Ty&amp;&gt;
	{	// remove reference
	    typedef _Ty _Type;
	};

    template&lt;class _Ty&gt;
	struct _Remove_reference&lt;_Ty&amp;&amp;&gt;
	{	// remove rvalue reference
	    typedef _Ty _Type;
	};

Unfortunately it&#39;s still as confusing and I don&#39;t get it.

I know that this is all because of my lack of basic syntax skills about C++. 
I&#39;d like to know how these work thoroughly and any documents that I can get on the internet will be more than welcomed. (If you can just explain this, that will be awesome too).

How does std::move() transfer values into RValues?

The below code works on Visual Studio 2008 with and without optimization. But it only works on g++ without optimization (O0).

    #include &lt;cstdlib&gt;
    #include &lt;iostream&gt;
    #include &lt;cmath&gt;

    double round(double v, double digit)
    {
        double pow = std::pow(10.0, digit);
        double t = v * pow;
        //std::cout &lt;&lt; &quot;t:&quot; &lt;&lt; t &lt;&lt; std::endl;
        double r = std::floor(t + 0.5);
        //std::cout &lt;&lt; &quot;r:&quot; &lt;&lt; r &lt;&lt; std::endl;
        return r / pow;
    }

    int main(int argc, char *argv[])
    {
        std::cout &lt;&lt; round(4.45, 1) &lt;&lt; std::endl;
        std::cout &lt;&lt; round(4.55, 1) &lt;&lt; std::endl;
    }

The output should be:

    4.5
    4.6

But g++ with optimization (`O1` - `O3`) will output:

    4.5
    4.5

If I add the `volatile` keyword before t, it works, so might there be some kind of optimization bug?

Test on g++ 4.1.2, and 4.4.4.

Here is the result on ideone:
http://ideone.com/Rz937

And the option I test on g++ is simple:

    g++ -O2 round.cpp

The more interesting result, even I turn on `/fp:fast` option on Visual Studio 2008, the result still is correct.

**Further question:**

I was wondering, should I always turn on the `-ffloat-store` option?

Because the g++ version I tested is **shipped with [CentOS][1]/[Red Hat Linux][2] 5 and CentOS/Redhat 6**.

I compiled many of my programs under these platforms, and I am worried it will cause unexpected bugs inside my programs. It seems a little difficult to investigate all my C++ code and used libraries whether they have such problems. Any suggestion?

Is anyone interested in why even `/fp:fast` turned on, Visual Studio 2008 still works? It seems like Visual&amp;nbsp;Studio&amp;nbsp;2008 is more reliable at this problem than g++?

  [1]: http://en.wikipedia.org/wiki/CentOS
  [2]: http://en.wikipedia.org/wiki/Red_Hat_Linux



Different floating point result with optimization enabled - compiler bug?

I find recursion, apart from very straight forward ones like factorial, very difficult to understand. The following snippet prints all permutations of a string. Can anyone help me understand it. What is the way to go about to understand recursion properly.

    void permute(char a[], int i, int n)
    {
       int j;
       if (i == n)
         cout &lt;&lt; a &lt;&lt; endl;
       else
       {
           for (j = i; j &lt;= n; j++)
           {
              swap(a[i], a[j]);    		 
              permute(a, i+1, n);
              swap(a[i], a[j]);
           }
       }
    } 
    
    int main()
    {
       char a[] = &quot;ABCD&quot;;
       permute(a, 0, 3);
       getchar();
       return 0;
    }

Understanding Recursion to generate permutations

There is such code:

    #include &lt;iostream&gt;
    
    int main(){
      unsigned int* wsk2 = new unsigned int(5);
      std::cout &lt;&lt; &quot;wsk2: &quot; &lt;&lt; wsk2 &lt;&lt; &quot; &quot; &lt;&lt; *wsk2 &lt;&lt; std::endl;
      delete wsk2;
      wsk2 = new unsigned int;
      std::cout &lt;&lt; &quot;wsk2: &quot; &lt;&lt; wsk2 &lt;&lt; &quot; &quot; &lt;&lt; *wsk2 &lt;&lt; std::endl;
      return 0;
    }

Result:

    wsk2: 0x928e008 5
    wsk2: 0x928e008 0

I have read that `new` doesn&#39;t initialize memory with zeroes. But here it seems that it does. How does it work?


Operator new initializes memory to zero

In C++11 `basic_string::c_str` is defined to be exactly the same as `basic_string::data`, which is in turn defined to be exactly the same as `*(begin() + n)` and `*(&amp;*begin() + n)` (when `0 &lt;= n &lt; size()`).

I cannot find anything that requires the string to always have a null character at its end.

Does this mean that `c_str()` is no longer guaranteed to produce a null-terminated string?


Is string::c_str() no longer null terminated in C++11?

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?

How do I typedef a function pointer with the C++11 using syntax?

As the title says, I have this code:
```c
    typedef struct Book{
        int id;
        char title[256];
        char summary[2048];
        int numberOfAuthors;
        struct Author *authors;
    };


    typedef struct Author{
        char firstName[56];
        char lastName[56];
    };


    typedef struct Books{
        struct Book *arr;
        int numberOfBooks;
    };
```


I get these errors from gcc :

    bookstore.c:8:2: error: unknown type name ‘Author’
    bookstore.c:9:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:15:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:21:2: error: unknown type name ‘Book’
    bookstore.c:23:1: warning: useless storage class specifier in empty declaration [enabled by default]



No warnings and no errors occur if I change the typedefs like this:

```c
    typedef struct{
        char firstName[56];
        char lastName[56];
    } Author;
```

Having searched through _[C Programming Language, 2nd Edition][1]_ and googled for a couple of hours, I can&#39;t figure out why the first implementation won&#39;t work.
    
[1]:http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628

Content Type	Original Author	Original Content on Stackoverflow
Question	vivek	View Question on Stackoverflow
Solution 1 - C++	Sven Marnach	View Answer on Stackoverflow
Solution 2 - C++	Jonathan Grynspan	View Answer on Stackoverflow

Unusual typedef use in C++

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Create nuget package with multiple DLLs

ant build.xml file doesn't exist

Attributions