Quoting from [Wikipedia](http://en.wikipedia.org/wiki/Long_double):

&gt; On the x86 architecture, most compilers implement long double as the 80-bit extended precision type supported by that hardware (sometimes stored as 12 or 16 bytes to maintain data structure .

and

&gt; Compilers may also use long double for a 128-bit quadruple precision format, which is currently implemented in software.

In other words, yes, a `long double` *may* be able to store a larger range of values than a `double`.  But it&#39;s completely up to the compiler.

For modern compilers on x64, Clang and GCC uses 16-byte double for `long double` while VC++ uses 8-byte double. In other words, with Clang and GCC you get higher precision double but for VC++ `long double` is same as `double`. The modern x86 CPUs do support these 16-byte doubles so I think Clang and GCC are doing the right thing and allows you to access lower level hardware capability using higher level language primitives.

The standard byte sizes for numbers are the guaranteed minimum sizes across all platforms. They may be larger on some systems, but they will never be smaller.

I&#39;ve read:

- [Wikipedia][1]
- [Code Generation vs. Metaprogramming][2]
- [The art of Metaprogramming][3]
- [Metaprogramming at c2.com][4]

and I confess some confusion at the purpose behind metaprogramming/code generation.

Does anyone have a concrete example of where they use metaprogramming/code generation? Even better would be an accompanying explanation of why it was better than an alternative.

**edit**:
Would [Thistle][5] be considered metaprogramming?


  [1]: http://en.wikipedia.org/wiki/Metaprogramming
  [2]: http://www.qcodo.com/wiki/article/background/metaprogramming
  [3]: http://www.ibm.com/developerworks/linux/library/l-metaprog3/?ca=dgr-wikiaMetaprogP3
  [4]: http://c2.com/cgi/wiki?MetaProgramming
  [5]: http://www.fogcreek.com/FogBugz/blog/post/The-Origin-of-Wasabi.aspx

What&#39;s the use of metaprogramming?

Hay I have an element like this

    &lt;span class=&#39;a.b&#39;&gt;

Unfortunately this class name comes from an eCommerce application and cannot be changed.

Can I style a class name with a dot in it?

like

    .a.b { }

Styling elements with a dot (.) in the class name

I know that size of various data types can change depending on which system I am on.

I use XP 32bits, and using the `sizeof()` operator in C++, it seems like `long double` is 12 bytes, and `double` is 8.

However, most major sources states that `long double` is 8 bytes, and the range is therefore the same as a `double`.

How come I have 12 bytes? If `long double` is indeed 12 bytes, doesn&#39;t this extends the range of value also? Or the long signature is only used (the compiler figures) when the value exceed the range of a double, and thus, extends beyond 8 bytes?


long double vs double

I know that size of various data types can change depending on which system I am on.
I use XP 32bits, and using the <code>sizeof()</code> operator in C++, it seems like <code>long double</code> is 12 bytes, and <code>double</code> is 8.
However, most major sources states that <code>long double</code> is 8 bytes, and the range is therefore the same as a <code>double</code>.
How come I have 12 bytes? If <code>long double</code> is indeed 12 bytes, doesn't this extends the range of value also? Or the long signature is only used (the compiler figures) when the value exceed the range of a double, and thus, extends beyond 8 bytes?

I&#39;d like to prepare a little educational tool for SO which should help beginners (and intermediate) programmers to recognize and challenge their unwarranted assumptions in C, C++ and their platforms.

Examples: 

* &quot;integers wrap around&quot;
* &quot;everyone has ASCII&quot;
* &quot;I can store a function pointer in a void*&quot;

I figured that a small test program could be run on various platforms, which runs the &quot;plausible&quot; assumptions which are, from our experience in SO, usually made by many inexperienced/semiexperienced mainstream developers and record the ways they break on diverse machines.

The goal of this is not to prove that it is &quot;safe&quot; to do something (which would be impossible to do, the tests prove only anything if they break), but instead to demonstrate to even the most uncomprehending individual **how the most inconspicuous expression break on a different machine, if it has a undefined or implementation defined behavior.**. 

To achieve this I would like to ask you:

* How can this idea be improved?
* Which tests would be good and how should they look like?
* Would you run the tests on the platforms you can get your hands on and post the results, so that we end up with a database of platforms, how they differ and why this difference is allowed?

----
Here&#39;s the current version for the test toy:

    #include &lt;stdio.h&gt;
    #include &lt;limits.h&gt;
    #include &lt;stdlib.h&gt;
    #include &lt;stddef.h&gt;
    int count=0;
    int total=0;
    void expect(const char *info, const char *expr)
    {
        printf(&quot;..%s\n   but &#39;%s&#39; is false.\n&quot;,info,expr);
        fflush(stdout);
        count++;
    }
    #define EXPECT(INFO,EXPR) if (total++,!(EXPR)) expect(INFO,#EXPR)
    
    /* stack check..How can I do this better? */
    ptrdiff_t check_grow(int k, int *p)
    {
        if (p==0) p=&amp;k;
        if (k==0) return &amp;k-p;
        else return check_grow(k-1,p);
    }
    #define BITS_PER_INT (sizeof(int)*CHAR_BIT)
    
    int bits_per_int=BITS_PER_INT;
    int int_max=INT_MAX;
    int int_min=INT_MIN;
    
    /* for 21 - left to right */
    int ltr_result=0;
    unsigned ltr_fun(int k)
    {
        ltr_result=ltr_result*10+k;
        return 1;
    }
    
    int main()
    {
        printf(&quot;We like to think that:\n&quot;);
        /* characters */
        EXPECT(&quot;00 we have ASCII&quot;,(&#39;A&#39;==65));
        EXPECT(&quot;01 A-Z is in a block&quot;,(&#39;Z&#39;-&#39;A&#39;)+1==26);
        EXPECT(&quot;02 big letters come before small letters&quot;,(&#39;A&#39;&lt;&#39;a&#39;));
        EXPECT(&quot;03 a char is 8 bits&quot;,CHAR_BIT==8);
        EXPECT(&quot;04 a char is signed&quot;,CHAR_MIN==SCHAR_MIN);
    
        /* integers */
        EXPECT(&quot;05 int has the size of pointers&quot;,sizeof(int)==sizeof(void*));
        /* not true for Windows-64 */
        EXPECT(&quot;05a long has at least the size of pointers&quot;,sizeof(long)&gt;=sizeof(void*));
    
        EXPECT(&quot;06 integers are 2-complement and wrap around&quot;,(int_max+1)==(int_min));
        EXPECT(&quot;07 integers are 2-complement and *always* wrap around&quot;,(INT_MAX+1)==(INT_MIN));
        EXPECT(&quot;08 overshifting is okay&quot;,(1&lt;&lt;bits_per_int)==0);
        EXPECT(&quot;09 overshifting is *always* okay&quot;,(1&lt;&lt;BITS_PER_INT)==0);
        {
            int t;
            EXPECT(&quot;09a minus shifts backwards&quot;,(t=-1,(15&lt;&lt;t)==7));
        }
        /* pointers */
        /* Suggested by jalf */
        EXPECT(&quot;10 void* can store function pointers&quot;,sizeof(void*)&gt;=sizeof(void(*)()));
        /* execution */
        EXPECT(&quot;11 Detecting how the stack grows is easy&quot;,check_grow(5,0)!=0);
        EXPECT(&quot;12 the stack grows downwards&quot;,check_grow(5,0)&lt;0);
    
        {
            int t;
            /* suggested by jk */
            EXPECT(&quot;13 The smallest bits always come first&quot;,(t=0x1234,0x34==*(char*)&amp;t));
        }
        {
            /* Suggested by S.Lott */
            int a[2]={0,0};
            int i=0;
            EXPECT(&quot;14 i++ is strictly left to right&quot;,(i=0,a[i++]=i,a[0]==1));
        }
        {
            struct {
                char c;
                int i;
            } char_int;
            EXPECT(&quot;15 structs are packed&quot;,sizeof(char_int)==(sizeof(char)+sizeof(int)));
        }
        {
            EXPECT(&quot;16 malloc()=NULL means out of memory&quot;,(malloc(0)!=NULL));
        }
    
        /* suggested by David Thornley */
        EXPECT(&quot;17 size_t is unsigned int&quot;,sizeof(size_t)==sizeof(unsigned int));
        /* this is true for C99, but not for C90. */
        EXPECT(&quot;18 a%b has the same sign as a&quot;,((-10%3)==-1) &amp;&amp; ((10%-3)==1));
    
        /* suggested by nos */
        EXPECT(&quot;19-1 char&lt;short&quot;,sizeof(char)&lt;sizeof(short));
        EXPECT(&quot;19-2 short&lt;int&quot;,sizeof(short)&lt;sizeof(int));
        EXPECT(&quot;19-3 int&lt;long&quot;,sizeof(int)&lt;sizeof(long));
        EXPECT(&quot;20 ptrdiff_t and size_t have the same size&quot;,(sizeof(ptrdiff_t)==sizeof(size_t)));
    #if 0
        {
            /* suggested by R. */
            /* this crashed on TC 3.0++, compact. */
            char buf[10];
            EXPECT(&quot;21 You can use snprintf to append a string&quot;,
                   (snprintf(buf,10,&quot;OK&quot;),snprintf(buf,10,&quot;%s!!&quot;,buf),strcmp(buf,&quot;OK!!&quot;)==0));
        }
    #endif
    
        EXPECT(&quot;21 Evaluation is left to right&quot;,
               (ltr_fun(1)*ltr_fun(2)*ltr_fun(3)*ltr_fun(4),ltr_result==1234));
    		   
    	{
    	#ifdef __STDC_IEC_559__
    	int STDC_IEC_559_is_defined=1;
    	#else 
    	/* This either means, there is no FP support
    	 *or* the compiler is not C99 enough to define  __STDC_IEC_559__
    	 *or* the FP support is not IEEE compliant. */
    	int STDC_IEC_559_is_defined=0;
    	#endif
        EXPECT(&quot;22 floating point is always IEEE&quot;,STDC_IEC_559_is_defined);
    	}
    	
        printf(&quot;From what I can say with my puny test cases, you are %d%% mainstream\n&quot;,100-(100*count)/total);
        return 0;
    }

----

Oh, and I made this community wiki right from the start because I figured that people want to edit my blabber when they read this.

**UPDATE** Thanks for your input. I&#39;ve added a few cases from your answers and will see if I can set up a github for this like Greg suggested.

**UPDATE**:
I&#39;ve created a github repo for this, the file is &quot;gotcha.c&quot;: 

* http://github.com/lutherblissett/disenchanter

Please answer here with patches or new ideas, so they can be discussed or clarified here. I will merge them into gotcha.c then.



What belongs in an educational tool to demonstrate the unwarranted assumptions people make in C/C++?

I have an array `int arr[5]` that is passed to a function `fillarr(int arr[])`:

    int fillarr(int arr[])
    {
        for(...);
        return arr;
    }

1. How can I return that array?
2. How will I use it, say I returned a pointer how am I going to access it?

Return array in a function

Has anyone tried to use [`gold`](http://en.wikipedia.org/wiki/Gold_%28linker%29) instead of `ld`?

`gold` [promises](http://www.airs.com/blog/archives/38) to be much faster than `ld`, so it may help speeding up test cycles for large C++ applications, but can it be used as drop-in replacement for ld?

Can `gcc`/`g++` directly call `gold`.?

Are there any know bugs or problems?

Although `gold` is part of the GNU binutils since a while, I have found almost no &quot;success stories&quot; or even &quot;Howtos&quot; in the Web.

(*Update: added links to gold and blog entry explaining it*)

Replacing ld with gold - any experience?

Hi I asked a question today about [How to insert different types of objects in the same vector array ][1] and my code in that question was 

     gate* G[1000];
    G[0] = new ANDgate() ;
    G[1] = new ORgate;
    //gate is a class inherited by ANDgate and ORgate classes
    class gate
    {
     .....
     ......
     virtual void Run()
       {   //A virtual function
       }
    };
    class ANDgate :public gate 
      {.....
       .......
       void Run()
       {
        //AND version of Run
       }  

    };
     class ORgate :public gate 
      {.....
       .......
       void Run()
       {
        //OR version of Run
       }  

    };      
    //Running the simulator using overloading concept
     for(...;...;..)
     {
      G[i]-&gt;Run() ;  //will run perfectly the right Run for the right Gate type
     } 
and I wanted to use vectors so someone wrote that I should do that :

    std::vector&lt;gate*&gt; G;
    G.push_back(new ANDgate); 
    G.push_back(new ORgate);
    for(unsigned i=0;i&lt;G.size();++i)
    {
      G[i]-&gt;Run();
    }

but then he and many others suggested that I would better use [Boost pointer containers  
][2] or `shared_ptr`. I have spent the last 3 hours reading about this topic, but the documentation seems pretty advanced to me . ****Can anyone give me a small code example of `shared_ptr` usage and why they suggested using `shared_ptr`. Also are there other types like `ptr_vector`, `ptr_list` and `ptr_deque`**  **

  
Edit1: I have read a code example too that included:

    typedef boost::shared_ptr&lt;Foo&gt; FooPtr;
    .......
    int main()
    {
      std::vector&lt;FooPtr&gt;         foo_vector;
    ........
    FooPtr foo_ptr( new Foo( 2 ) );
      foo_vector.push_back( foo_ptr );
    ...........
    }

And I don&#39;t understand the syntax!





[1]: https://stackoverflow.com/questions/3475030/different-types-of-objects-in-the-same-vector-array
  [2]: http://www.boost.org/doc/libs/1_43_0/libs/ptr_container/doc/guidelines.html

Example to use shared_ptr?

How can I `realloc` in C++? It seems to be missing from the language - there is `new` and `delete` but not `resize`!

I need it because as my program reads more data, I need to reallocate the buffer to hold it. I don&#39;t think `delete`ing the old pointer and `new`ing a new, bigger one, is the right option. 

How do you &#39;realloc&#39; in C++?

I have a variable `float slope` that sometimes will have a value of `nan` when printed out since a division by` 0` sometimes happens.

I am trying to do an if-else for when that happens. How can I do that? `if (slope == nan)` doesn&#39;t seem to work.


Objective-C - float checking for nan

Is there a native way (preferably without implementing your own method) to check that a string is parseable with `Double.parseDouble()`?

How to check that a string is parseable to a double?

Why do I get an error of &quot;can&#39;t multiply sequence by non-int of type &#39;float&#39;&quot;? from the following code:


    def nestEgVariable(salary, save, growthRates):
        SavingsRecord = []
        fund = 0
        depositPerYear = salary * save * 0.01
        for i in growthRates:  
            fund = fund * (1 + 0.01 * growthRates) + depositPerYear
            SavingsRecord += [fund,]
        return SavingsRecord 
    
    
    print nestEgVariable(10000,10,[3,4,5,0,3])


can&#39;t multiply sequence by non-int of type &#39;float&#39;

    $a = &#39;35&#39;;
    $b = &#39;-34.99&#39;;
    echo ($a + $b);

Results in 0.009999999999998

What is up with that? I wondered why my program kept reporting odd results.

Why doesn&#39;t PHP return the expected 0.01?

PHP - Floating Number Precision

I&#39;ve always been told _never_ to represent money with `double` or `float` types, and this time I pose the question to you: why? 

I&#39;m sure there is a very good reason, I simply do not know what it is.

Why not use Double or Float to represent currency?

I am using the latest gcc with Netbeans on Windows. Why doesn&#39;t `long double` work? Is the `printf` specifier `%lf` wrong?

Code:

    #include &lt;stdio.h&gt;
    
    int main(void)
    {
        float aboat = 32000.0;
        double abet = 5.32e-5;
        long double dip = 5.32e-5;
    
        printf(&quot;%f can be written %e\n&quot;, aboat, aboat);
        printf(&quot;%f can be written %e\n&quot;, abet, abet);
        printf(&quot;%lf can be written %le\n&quot;, dip, dip);
    
        return 0;
    }

Output:

    32000.000000 can be written 3.200000e+004
    0.000053 can be written 5.320000e-005
    -1950228512509697500000000000000000000000000000000000000000000000000000000000000
    000000000000000000000000000000000000000000000000000000000000000000000000.000000
    can be written 2.725000e+002
    Press [Enter] to close the terminal ...


Content Type	Original Author	Original Content on Stackoverflow
Question	CppLearner	View Question on Stackoverflow
Solution 1 - C++	Borealid	View Answer on Stackoverflow
Solution 2 - C++	Shital Shah	View Answer on Stackoverflow
Solution 3 - C++	scott77777	View Answer on Stackoverflow

long double vs double

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Styling elements with a dot (.) in the class name

What's the use of metaprogramming?

Attributions