I have two structs: struct struct_A {   uint8_t v1[4];   // 4 bytes   uint8_t v2; };  struct struct_B {   uint32_t v1;  // 4 bytes   uint8_t v2; // 1 byte };  I obtain their sizes by using the code: std::cout&lt;&lt;&quot;size of struct_A is: &quot;&lt;&lt;(sizeof(struct_A))    &lt;&lt;std::endl; std::cout&lt;&lt;&quot;size of struct_A::v1 is: &quot;&lt;&lt;(sizeof(struct_A::v1))&lt;&lt;std::endl; std::cout&lt;&lt;&quot;size of struct_A::v2 is: &quot;&lt;&lt;(sizeof(struct_A::v2))&lt;&lt;std::endl; std::cout&lt;&lt;&quot;size of struct_B is: &quot;&lt;&lt;(sizeof(struct_B))    &lt;&lt;std::endl; std::cout&lt;&lt;&quot;size of struct_B::v1 is: &quot;&lt;&lt;(sizeof(struct_B::v1))&lt;&lt;std::endl; std::cout&lt;&lt;&quot;size of struct_B::v2 is: &quot;&lt;&lt;(sizeof(struct_B::v2))&lt;&lt;std::endl;  And I get output: size of struct_A is: 5 size of struct_A::v1 is: 4 size of struct_A::v2 is: 1 size of struct_B is: 8 size of struct_B::v1 is: 4 size of struct_B::v2 is: 1  How do I understand the size of struct_A and size of struct_B are different? Thanks.
1450
Why does the sizeof operator return a size larger for a structure than the total sizes of the structure's members?
12125
This question was .  Now I'd like to learn the differences between a struct and a class in C++. Please discuss the technical differences as well as reasons for choosing one or the other in OO design.  I'll start with an obvious difference:   If you don't specify public: or private:, members of a struct are public by default; members of a class are private by default.   I'm sure there are other differences to be found in the obscure corners of the C++ specification.
40546
In C/C++, what an unsigned char is used for? How is it different from a regular char?
52593
Yesterday, I found myself writing code like this:  SomeStruct getSomeStruct() {     SomeStruct input;      cin &gt;&gt; input.x;     cin &gt;&gt; input.y; }   Of course forgetting to actually return the struct I just created.  Oddly enough, the values in the struct that was returned by this function got initialized to zero (when compiled using g++ that is).  Is this just a coincidence or did another SomeStruct get created and initialized somewhere implicitly?
38175
For example: sizeof(char*) returns 4.  As does int*, long long*, everything that I've tried.  Are there any exceptions to this?
114469
I was wondering what could be the size of an object of an empty class. It surely could not be 0 bytes since it should be possible to reference and point to it like any other object. But, how big is such an object?  I used this small program:  #include &lt;iostream&gt; using namespace std;  class Empty {};  int main() {     Empty e;     cerr &lt;&lt; sizeof(e) &lt;&lt; endl;     return 0; }   The output I got on both Visual C++ and Cygwin-g++ compilers was 1 byte! This was a little surprising to me since I was expecting it to be of the size of the machine word (32 bits or 4 bytes).  Can anyone explain why the size of 1 byte? Why not 4 bytes? Is this dependent on compiler or the machine too? Also, can someone give a more cogent reason for why an empty class object will not be of size 0 bytes?
26276
A few weeks back I was using std::ifstream to read in some files and it was failing immediately on open because the file was larger than 4GB. At the time I couldnt find a decent answer as to why it was limited to 32 bit files sizes, so I wrote my own using native OS API.  So, my question then: Is there a way to handle files greater than 4GB in size using std::ifstream/std::ostream (IE: standard c++)  EDIT: Using the STL implementation from the VC 9 compiler (Visual Studio 2008).  EDIT2: Surely there has to be standard way to support file sizes larger than 4GB.
93400
What is the order in which the destructors and the constructors are called in C++? Using the examples of some Base classes and Derived Classes
84760
I am surprised that I can't initialize my fields in structs, why is it like that? Like:  struct MyStruct {     private int a = 90; }   but it's a complie time error. I don't know why it's a problem? Please explain this to me.
69127
I'm looking for detailed information regarding the size of basic C++ types. I know that it depends on the architecture (16 bits, 32 bits, 64 bits) and the compiler.  But are there any standards for C++?  I'm using Visual Studio 2008 on a 32-bit architecture. Here is what I get:  char  : 1 byte short : 2 bytes int   : 4 bytes long  : 4 bytes float : 4 bytes double: 8 bytes   I tried to find, without much success, reliable information stating the sizes of char, short, int, long, double, float (and other types I didn't think of) under different architectures and compilers.
17141
The code below compiles, but has different behavior for the char type than for the int types.  In particular     cout &lt;&lt; getIsTrue&lt; isX&lt;int8&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;uint8&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;char&gt;::ikIsX  &gt;() &lt;&lt; endl;   result in 3 instantiations of templates for three types: int8, uint8 and char. What gives?  The same is not true for ints: int and uint32 which result in the same template instantiation, and signed int another.  The reason seems to be that C++ sees char, signed char and unsigned char as three different types. Whereas int is the same as a signed int. Is this right or am I missing something?  #include &lt;iostream&gt;  using namespace std;  typedef   signed char       int8; typedef unsigned char      uint8; typedef   signed short      int16; typedef unsigned short     uint16; typedef   signed int        int32; typedef unsigned int       uint32; typedef   signed long long  int64; typedef unsigned long long uint64;  struct TrueType {}; struct FalseType {};  template &lt;typename T&gt; struct isX {    typedef typename T::ikIsX ikIsX; };   // This  int==int32 is ambiguous //template &lt;&gt;            struct isX&lt;int  &gt;    { typedef FalseType ikIsX; };  // Fails template &lt;&gt;            struct isX&lt;int32  &gt;  { typedef FalseType ikIsX; }; template &lt;&gt;            struct isX&lt;uint32 &gt;  { typedef FalseType ikIsX; };   // Whay isn't this ambiguous? char==int8 template &lt;&gt;            struct isX&lt;char  &gt;  { typedef FalseType ikIsX; }; template &lt;&gt;            struct isX&lt;int8  &gt;  { typedef FalseType ikIsX; }; template &lt;&gt;            struct isX&lt;uint8 &gt;  { typedef FalseType ikIsX; };   template &lt;typename T&gt; bool getIsTrue(); template &lt;&gt;           bool getIsTrue&lt;TrueType&gt;() { return true; } template &lt;&gt;           bool getIsTrue&lt;FalseType&gt;() { return false; }  int main(int, char **t ) {    cout &lt;&lt; sizeof(int8) &lt;&lt; endl;  // 1    cout &lt;&lt; sizeof(uint8) &lt;&lt; endl; // 1    cout &lt;&lt; sizeof(char) &lt;&lt; endl;  // 1     cout &lt;&lt; getIsTrue&lt; isX&lt;int8&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;uint8&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;char&gt;::ikIsX  &gt;() &lt;&lt; endl;     cout &lt;&lt; getIsTrue&lt; isX&lt;int32&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;uint32&gt;::ikIsX  &gt;() &lt;&lt; endl;    cout &lt;&lt; getIsTrue&lt; isX&lt;int&gt;::ikIsX  &gt;() &lt;&lt; endl;  }   I'm using g++ 4.something
86999
Admittedly I don't get it. Say you have a memory with a memory word of length of 1 byte. Why can't you access a 4 byte long variable in a single memory access on an unaligned address(i.e. not divisible by 4), as it's the case with aligned addresses?
107235
#include&lt;iostream&gt; using namespace std;  class A  {    int a;    int b;    public:    void eat()    {       cout&lt;&lt;"A::eat()"&lt;&lt;endl;    } };  class B: public A {    public:    void eat()    {        cout&lt;&lt;"B::eat()"&lt;&lt;endl;     }  };  class C: public A {     public:    void eat()     {        cout&lt;&lt;"C::eat()"&lt;&lt;endl;     }  };  class D: public B, C {  };  int foo(A *ptr) {  ptr-&gt;eat();  } main() {  D obj; foo(&amp;(obj.B)); //error. How do i call with D's B part.  }   The above foo call is a compile time error.  I want to call foo with obj's B part without using virtual inheritance. How do i do that.   Also, in case of virtual inheritance, why the offset information need to be stored in the vtable. This can be determined at the compile time itself. In the above case, if we pass foo with D's object, at compile time only we can calculate the offset of D's A part.
73638
Is there any advantage over using a class over a struct in cases such as these?  (note: it will only hold variables, there will never be functions)  class Foo {  private:       struct Pos { int x, y, z }; public:        Pos Position;  };   Versus:  struct Foo {    struct Pos { int x, y, z } Pos; };     Similar questions:
105349
What is the difference between \big[ (or equivalently \big() and \bigl[? Is it always necessary to mention l (left) and r (right)?
27559
Suppose I have a std::vector (let's call it myVec) of size N.  What's the simplest way to construct a new vector consisting of a copy of elements X through Y, where 0 &lt;= X &lt;= Y &lt;= N-1?  For example, myVec [100000] through myVec [100999] in a vector of size 150000.  If this cannot be done efficiently with a vector, is there another STL datatype that I should use instead?
16626
I'm trying to read binary data using C#. I have all the information about the layout of the data in the files I want to read. I'm able to read the data "chunk by chunk", i.e. getting the first 40 bytes of data converting it to a string, get the next 40 bytes.  Since there are at least three slightly different version of the data, I would like to read the data directly into a struct. It just feels so much more right than by reading it "line by line".  I have tried the following approach but to no avail:  StructType aStruct; int count = Marshal.SizeOf(typeof(StructType)); byte[] readBuffer = new byte[count]; BinaryReader reader = new BinaryReader(stream); readBuffer = reader.ReadBytes(count); GCHandle handle = GCHandle.Alloc(readBuffer, GCHandleType.Pinned); aStruct = (StructType) Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(StructType)); handle.Free();   The stream is an opened FileStream from which I have began to read from. I get an AccessViolationException when using Marshal.PtrToStructure.  The stream contains more information than I'm trying to read since I'm not interested in data at the end of the file.  The struct is defined like:  [StructLayout(LayoutKind.Explicit)] struct StructType {     [FieldOffset(0)]     public string FileDate;     [FieldOffset(8)]     public string FileTime;     [FieldOffset(16)]     public int Id1;     [FieldOffset(20)]     public string Id2; }   The examples code is changed from original to make this question shorter.  How would I read binary data from a file into a struct?