Originally they were movable.  This turned out to be a design flaw on my part, and discovered by Alberto Ganesh Barbati:

http://cplusplus.github.io/LWG/lwg-defects.html#911

The issue shows a few examples where `ostream` gets moved and/or swapped, and the results are surprising, instead of expected.  I was convinced that these types should not be publicly movable nor swappable by this issue.

I&#39;m using Spring 3 and Thymeleaf to make some webpages and I am lost as for how to show messages like this:

welcome.message=Hello {0}, welcome!

and then replace {0} with the user name inside thymeleaf tags:

    &lt;h1 th:text=&quot;#{welcome.message}&quot;&gt;Welcome Placeholder&lt;/h1&gt;

I&#39;m not even sure if {0} is the right syntax for the bundle message.

How to show localization messages with parameters in Spring 3 / Thymeleaf

I am trying to make the absolute simplest minimal example of how to pass strings to and from a C++ DLL in C#.

My C++ looks like this:

    using std::string;

    extern &quot;C&quot; {
        string concat(string a, string b){
            return a + b;
        }
    }

With a header like

    using std::string;

    extern &quot;C&quot; {
        // Returns a + b
        __declspec(dllexport) string concat(string a, string b);
    }

My C# is

    [DllImport(&quot;*****.dll&quot;, CallingConvention = CallingConvention.Cdecl)]
        static extern string concat(string a, string b);
    }

And I am calling it with:
     Console.WriteLine(concat(&quot;a&quot;, &quot;b&quot;));

But this gives a System.AccessViolationException. This seems like it out to be the most trivial thing to deal with, but I am completely stuck on it. When I tried to do a similar experiment with a function &quot;Add&quot; that took two doubles and returned a double I had no problems.


Passing strings from C# to C++ DLL and back -- minimal example

Clearly, streams can&#39;t be copied. It should be possible to move streams. According to 27.9.1.11 [ofstream.cons] paragraph 4 it is possible to move construct an `std::ofstream` (the same is true for `std::ifstream`, `std::fstream`, and the `std::*stringstream` variants). For example:

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;string&gt;
    
    std::ofstream makeStream(std::string const&amp; name) {
        return std::ofstream(name);
    }
    
    int main()
    {
        std::ofstream out{ makeStream(&quot;example.log&quot;) };
    }

Trying to move an `std::ostream`, e.g., to have a factory function creating an `std::ofstream`, an `std::ostringstream`, or some other stream according to a URN passed as argument doesn&#39;t work. `std::ostream` (well, the class template `std::basic_ostream` really) has a `protected` move constructor according to 27.7.3.1 [ostream].

Why can&#39;t `std::ostream` be moved itself?

Why can&#39;t std::ostream be moved?

Clearly, streams can't be copied. It should be possible to move streams. According to 27.9.1.11 [ofstream.cons] paragraph 4 it is possible to move construct an <code>std::ofstream</code> (the same is true for <code>std::ifstream</code>, <code>std::fstream</code>, and the <code>std::*stringstream</code> variants). For example:
<pre><code class="hljs language-c">#include &#x3C;iostream>
#include &#x3C;fstream>
#include &#x3C;string>

std::ofstream makeStream(std::string const&#x26; name) {
 return std::ofstream(name);
}

int main()
{
 std::ofstream out{ makeStream("example.log") };
}
</code></pre>
Trying to move an <code>std::ostream</code>, e.g., to have a factory function creating an <code>std::ofstream</code>, an <code>std::ostringstream</code>, or some other stream according to a URN passed as argument doesn't work. <code>std::ostream</code> (well, the class template <code>std::basic_ostream</code> really) has a <code>protected</code> move constructor according to 27.7.3.1 [ostream].
Why can't <code>std::ostream</code> be moved itself?

What is the logic behind the &quot;using&quot; keyword in C++?

It is used in different situations and I am trying to find
if all those have something in common and there is a reason
why the &quot;using&quot; keyword is used as such.

    using namespace std; // to import namespace in the current namespace
    using T = int; // type alias
    using SuperClass::X; // using super class methods in derived class

What is the logic behind the &quot;using&quot; keyword in C++?

I am working on a single producer single consumer ring buffer implementation.I have two requirements:

1. Align a single heap allocated instance of a ring buffer to a cache line.
2. Align a field within a ring buffer to a cache line (to prevent false sharing).

My class looks something like:

    #define CACHE_LINE_SIZE 64  // To be used later.

    template&lt;typename T, uint64_t num_events&gt;
    class RingBuffer {  // This needs to be aligned to a cache line.
    public:
      ....
    
    private:
      std::atomic&lt;int64_t&gt; publisher_sequence_ ;
      int64_t cached_consumer_sequence_;
      T* events_;
      std::atomic&lt;int64_t&gt; consumer_sequence_;  // This needs to be aligned to a cache line.
    
    };

Let me first tackle point 1 i.e. **aligning a single heap allocated instance** of the class. There are a few ways:

1. Use the c++ 11 `alignas(..)` specifier:
    
       template&lt;typename T, uint64_t num_events&gt;
       class alignas(CACHE_LINE_SIZE) RingBuffer {
       public:
         ....
       
       private:
         // All the private fields.
       
       };

2. Use `posix_memalign(..)` + placement `new(..)` without altering the class definition. This suffers from not being platform independent:

       void* buffer;
       if (posix_memalign(&amp;buffer, 64, sizeof(processor::RingBuffer&lt;int, kRingBufferSize&gt;)) != 0) {
           perror(&quot;posix_memalign did not work!&quot;);
           abort();
       }
       // Use placement new on a cache aligned buffer.
       auto ring_buffer = new(buffer) processor::RingBuffer&lt;int, kRingBufferSize&gt;();

3. Use the GCC/Clang extension `__attribute__ ((aligned(#)))`
    
       template&lt;typename T, uint64_t num_events&gt;
       class RingBuffer {
       public:
         ....
       
       private:
         // All the private fields.
       
       } __attribute__ ((aligned(CACHE_LINE_SIZE)));

4. I tried to use the C++ 11 standardized `aligned_alloc(..)` function instead of `posix_memalign(..)` but GCC 4.8.1 on Ubuntu 12.04 could not find the definition in `stdlib.h`

Are all of these guaranteed to do the same thing? My goal is cache-line alignment so any method that has some limits on alignment (say double word) will not do. Platform independence which would point to using the standardized `alignas(..)` is a secondary goal.

I am not clear on whether `alignas(..)` and `__attribute__((aligned(#)))` have some limit which could be below the cache line on the machine. I can&#39;t reproduce this any more but while printing addresses I think I did not always get 64 byte aligned addresses with `alignas(..)`. On the contrary `posix_memalign(..)` seemed to always work. Again I cannot reproduce this any more so maybe I was making a mistake.

The second aim is to **align a field within a class/struct** to a cache line. I am doing this to prevent false sharing. I have tried the following ways:

1. Use the C++ 11 `alignas(..)` specifier:

       template&lt;typename T, uint64_t num_events&gt;
       class RingBuffer {  // This needs to be aligned to a cache line.
         public:
         ...
         private:
           std::atomic&lt;int64_t&gt; publisher_sequence_ ;
           int64_t cached_consumer_sequence_;
           T* events_;
           std::atomic&lt;int64_t&gt; consumer_sequence_ alignas(CACHE_LINE_SIZE);
       };

2. Use the GCC/Clang extension `__attribute__ ((aligned(#)))`

       template&lt;typename T, uint64_t num_events&gt;
       class RingBuffer {  // This needs to be aligned to a cache line.
         public:
         ...
         private:
           std::atomic&lt;int64_t&gt; publisher_sequence_ ;
           int64_t cached_consumer_sequence_;
           T* events_;
           std::atomic&lt;int64_t&gt; consumer_sequence_ __attribute__ ((aligned (CACHE_LINE_SIZE)));
       };

Both these methods seem to align `consumer_sequence` to an address 64 bytes after the beginning of the object so whether `consumer_sequence` is cache aligned depends on whether the object itself is cache aligned. Here my question is - are there any better ways to do the same?

**EDIT:**

The reason `aligned_alloc` did not work on my machine was that I was on eglibc 2.15 (Ubuntu 12.04). It worked on a later version of eglibc.

From the [man page][1]: *The function `aligned_alloc()` was added to glibc in version 2.16*.

This makes it pretty useless for me since I cannot require such a recent version of eglibc/glibc.


  [1]: http://linux.die.net/man/3/posix_memalign

What is the recommended way to align memory in C++11

I stumbled into this code for swapping two integers without using a temporary variable or the use of bitwise operators.

    int main(){
    
        int a=2,b=3;
        printf(&quot;a=%d,b=%d&quot;,a,b);
        a=(a+b)-(b=a);
        printf(&quot;\na=%d,b=%d&quot;,a,b);
        return 0;
    }

But I think this code has undefined behavior in the swap statement `a = (a+b) - (b=a);` as it does not contain any **sequence points** to determine the order of evaluation. 

My question is: *Is this an acceptable solution to swap two integers?*

Why is a = (a+b) - (b=a) a bad choice for swapping two integers?

What are the recommended parameters for [`CascadeClassifier::detectMultiScale()`][1] and depending on which factors I should change default parameters?

    void CascadeClassifier::detectMultiScale(
        const Mat&amp; image, 
        vector&lt;Rect&gt;&amp; objects, 
        double scaleFactor=1.1,
        int minNeighbors=3, 
        int flags=0, 
        Size minSize=Size(),
        Size maxSize=Size() )


  [1]: http://docs.opencv.org/modules/objdetect/doc/cascade_classification.html#cascadeclassifier-detectmultiscale

Recommended values for OpenCV detectMultiScale() parameters

`string_view` was a proposed feature within the C++ Library Fundamentals TS([N3921][1]) added to C++17

As far as i understand it is a type that represent some kind of string &quot;concept&quot; that is a view of any type of container that could store something viewable as a string.

 - Is this right ? 
 - Should the canonical
   `const std::string&amp;` parameter type become `string_view` ?
 - Is there another important point about `string_view` to take into consideration ?

  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3921.html

What is string_view?

Take the following standard passage:

&gt; `[C++11: 5.3.3/6]:` The result of `sizeof` and `sizeof...` is a constant of type `std::size_t`. _[ Note:_ `std::size_t` is defined in the standard header `&lt;cstddef&gt;` (18.2). _—end note ]_

Now:

&gt; `[C++11: 18.2/6]:` The type `size_t` is an implementation-defined unsigned integer type that is large enough to contain the size in bytes of any object.

Granted, the passage doesn&#39;t require that `size_t` is a type alias defined with `typedef`, but since it&#39;s explicitly stated to be made available by the standard header `&lt;cstddef&gt;`, I think we can take as read that failing to include `&lt;cstddef&gt;` should remove any guarantee that `size_t` shall be available to a program.

However, according to that first quote, we can regardless obtain an expression of type `std::size_t`.

[We can actually demonstrate both of these facts](http://coliru.stacked-crooked.com/a/2773cc8d2a92d4e7):

    int main()
    {
        typedef decltype(sizeof(0)) my_size_t;
        
        my_size_t x   = 0;  // OK
        std::size_t y = 1;  // error: &#39;size_t&#39; is not a member of &#39;std&#39;
    }

`std::size_t` is not visible to the program, but `sizeof(0)` still gives us one? Really?

**Is it therefore not correct to say that `5.3.3/6` is _flawed_, and that it actually has &quot;the same type as whatever `std::size_t` resolves to&quot;, but _not_ `std::size_t` itself?**

Sure, the two are one and the same if `std::size_t` is a type alias but, again, nowhere is this actually required.

Does `sizeof` *really* evaluate to a `std::size_t`? Can it?

I don&#39;t understand why would I ever do this:

    struct S { 
        int a; 
        S(int aa) : a(aa) {} 
        S() = default; 
    };

Why not just say:

    S() {} // instead of S() = default;

why bring in a new syntax for that?

The new syntax &quot;= default&quot; in C++11

    std::shared_ptr&lt;Object&gt; p1 = std::make_shared&lt;Object&gt;(&quot;foo&quot;);
    std::shared_ptr&lt;Object&gt; p2(new Object(&quot;foo&quot;));
Many google and stackoverflow posts are there on this, but I am not able to understand why `make_shared` is more efficient than directly using `shared_ptr`. 

Can someone explain me step by step sequence of objects created and operations done by both so that I will be able to understand how `make_shared` is efficient. I have given one example above for reference.

Difference in make_shared and normal shared_ptr in C++

I have the following piece of code that prompts the user for their cat&#39;s age and name:

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    int main()
    {
        int age;
        std::string name;

        std::cin &gt;&gt; age;
        std::getline(std::cin, name);
        
        if (std::cin)
        {
            std::cout &lt;&lt; &quot;My cat is &quot; &lt;&lt; age &lt;&lt; &quot; years old and their name is &quot; &lt;&lt; name &lt;&lt; std::endl;
        }
    }

What I find is that the age has been successfully read, but not the name. Here is the input and output:

&gt;     Input:
&gt;
&gt;     &quot;10&quot;
&gt;     &quot;Mr. Whiskers&quot;
&gt;
&gt;     Output:
&gt;
&gt;     &quot;My cat is 10 years old and their name is &quot;

Why has the name been omitted from the output? I&#39;ve given the proper input, but the code somehow ignores it. Why does this happen?

Why does std::getline() skip input after a formatted extraction?

I am using the GCC built-in type `__int128` for a few things in my C++ program, nothing really significant, at least not enough to justify to use BigInt library only for that and, yet, enough to prevent to remove it totally.

My problem comes when I run into the printing parts my classes, here is a minimal example:

    #include &lt;iostream&gt;

    int main()
    {
      __int128 t = 1234567890;

      std::cout &lt;&lt; t &lt;&lt; std::endl;

      return t;
    }

Commenting out the `std::cout` line will make this code to compile nicely with `g++`, but having it will cause the following error message:

    int128.c: In function ‘int main()’:
    int128.c:7:13: error: ambiguous overload for ‘operator&lt;&lt;’ (operand types are ‘std::ostream {aka std::basic_ostream&lt;char&gt;}’ and ‘__int128’)
       std::cout &lt;&lt; t &lt;&lt; std::endl;
                 ^
    int128.c:7:13: note: candidates are:
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:108:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; (*)(std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(__ostream_type&amp; (*__pf)(__ostream_type&amp;))
           ^
    /usr/include/c++/4.9/ostream:108:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__ostream_type&amp; (*)(std::basic_ostream&lt;char&gt;::__ostream_type&amp;) {aka std::basic_ostream&lt;char&gt;&amp; (*)(std::basic_ostream&lt;char&gt;&amp;)}’
    /usr/include/c++/4.9/ostream:117:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type&amp; (*)(std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type = std::basic_ios&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(__ios_type&amp; (*__pf)(__ios_type&amp;))
           ^
    /usr/include/c++/4.9/ostream:117:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__ios_type&amp; (*)(std::basic_ostream&lt;char&gt;::__ios_type&amp;) {aka std::basic_ios&lt;char&gt;&amp; (*)(std::basic_ios&lt;char&gt;&amp;)}’
    /usr/include/c++/4.9/ostream:127:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::ios_base&amp; (*)(std::ios_base&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(ios_base&amp; (*__pf) (ios_base&amp;))
           ^
    /usr/include/c++/4.9/ostream:127:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::ios_base&amp; (*)(std::ios_base&amp;)’
    /usr/include/c++/4.9/ostream:166:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long __n)
           ^
    /usr/include/c++/4.9/ostream:170:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned long __n)
           ^
    /usr/include/c++/4.9/ostream:174:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(bool) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(bool __n)
           ^
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:91:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(short int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:181:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(short unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned short __n)
           ^
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:105:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:192:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned int __n)
           ^
    /usr/include/c++/4.9/ostream:201:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long long int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long long __n)
           ^
    /usr/include/c++/4.9/ostream:205:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long long unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned long long __n)
           ^
    /usr/include/c++/4.9/ostream:220:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(double) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(double __f)
           ^
    /usr/include/c++/4.9/ostream:224:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(float) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(float __f)
           ^
    /usr/include/c++/4.9/ostream:232:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long double) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long double __f)
           ^
    /usr/include/c++/4.9/ostream:245:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(const void*) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(const void* __p)
           ^
    /usr/include/c++/4.9/ostream:245:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘const void*’
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:119:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__streambuf_type*) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__streambuf_type = std::basic_streambuf&lt;char&gt;] &lt;near match&gt;
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    /usr/include/c++/4.9/bits/ostream.tcc:119:5: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__streambuf_type* {aka std::basic_streambuf&lt;char&gt;*}’
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:493:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, unsigned char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, unsigned char __c)
         ^
    /usr/include/c++/4.9/ostream:488:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, signed char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, signed char __c)
         ^
    /usr/include/c++/4.9/ostream:482:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, char __c)
         ^
    /usr/include/c++/4.9/ostream:476:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp;, char) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;_CharT, _Traits&gt;&amp; __out, char __c)
         ^

Yes, I know, a lot of lines to explain that `__int128` is just not properly handled...

Is there a **simple** way to get `__int128` to be printed by the `iostream` as any other numeric types ?

EDIT: For those who are still confusing C and C++, yes, I read the question: [how to print __uint128_t number using gcc?](https://stackoverflow.com/questions/11656241/how-to-print-uint128-t-number-using-gcc) But, this was for C and not for C++ as I am asking now.

How to print __int128 in g++?

I was trying to solve this exercise  from www.spoj.com : [FCTRL - Factorial][1]

You don&#39;t really have to read it, just do it if you are curious :)

First I implemented it in **C++** (here is my solution):

    #include &lt;iostream&gt;
    using namespace std;
    
    int main() {
    	unsigned int num_of_inputs;
    	unsigned int fact_num;
    	unsigned int num_of_trailing_zeros;
    
    	std::ios_base::sync_with_stdio(false); // turn off synchronization with the C library’s stdio buffers (from https://stackoverflow.com/a/22225421/5218277)
    	
    	cin &gt;&gt; num_of_inputs;
    
    	while (num_of_inputs--)
    	{
    		cin &gt;&gt; fact_num;
    
    		num_of_trailing_zeros = 0;
    
    		for (unsigned int fives = 5; fives &lt;= fact_num; fives *= 5)
    			num_of_trailing_zeros += fact_num/fives;
    
    		cout &lt;&lt; num_of_trailing_zeros &lt;&lt; &quot;\n&quot;;
    	}
    
    	return 0;
    }

I uploaded it as the solution for **g++ 5.1**

The result was: *Time* 0.18 *Mem* 3.3M
[![C++ execution results][2]][2]


But then I saw some comments which claimed that their time execution was less than 0.1. Since I couldn&#39;t think about faster algorithm I tried to implement the same code in **C**:

    #include &lt;stdio.h&gt;
    
    int main() {
    	unsigned int num_of_inputs;
    	unsigned int fact_num;
    	unsigned int num_of_trailing_zeros;
    
    	scanf(&quot;%d&quot;, &amp;num_of_inputs);
    
    	while (num_of_inputs--)
    	{
    		scanf(&quot;%d&quot;, &amp;fact_num);
    
    		num_of_trailing_zeros = 0;
    
    		for (unsigned int fives = 5; fives &lt;= fact_num; fives *= 5)
    			num_of_trailing_zeros += fact_num/fives;
    
    		printf(&quot;%d&quot;, num_of_trailing_zeros);
    		printf(&quot;%s&quot;,&quot;\n&quot;);
    	}
    
    	return 0;
    }

I uploaded it as the solution for **gcc 5.1**

This time the result was: *Time* 0.02 *Mem* 2.1M
[![C execution results][3]][3]

Now the code is *almost the same*, I added `std::ios_base::sync_with_stdio(false);` to the C++ code as was suggested [here][4] to turn off the synchronization with the C library’s stdio buffers. I also split the `printf(&quot;%d\n&quot;, num_of_trailing_zeros);` to `printf(&quot;%d&quot;, num_of_trailing_zeros); printf(&quot;%s&quot;,&quot;\n&quot;);` to compensate for double call of `operator&lt;&lt;` in `cout &lt;&lt; num_of_trailing_zeros &lt;&lt; &quot;\n&quot;;`.

But I still saw **x9 better performance** and lower memory usage in C vs. C++ code.

Why is that?

**EDIT**

I fixed `unsigned long` to `unsigned int` in the C code. It should have been `unsigned int` and the results which are shown above are related to the new (`unsigned int`) version.

  [1]: http://www.spoj.com/problems/FCTRL/
  [2]: http://i.stack.imgur.com/oqpfY.jpg
  [3]: http://i.stack.imgur.com/PgZLu.jpg
  [4]: https://stackoverflow.com/a/22225421/5218277

Big difference (x9) in the execution time between almost identical code in C and C++

What does the *g* stand for in `std::iostream`&#39;s `gcount`, `tellg` and `seekg` members? And the *p* in `pcount`, `tellp` and `seekp`?

Why aren&#39;t they called just `count`, `tell` and `seek`?

Content Type	Original Author	Original Content on Stackoverflow
Question	Dietmar Kühl	View Question on Stackoverflow
Solution 1 - C++	Howard Hinnant	View Answer on Stackoverflow

Why can't std::ostream be moved?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Passing strings from C# to C++ DLL and back -- minimal example

How to show localization messages with parameters in Spring 3 / Thymeleaf

Attributions