Expert: Ralph McArdell - 10/1/2010

Question
I am trying to write this code using nested structures when I run my program however I get a request error. Here is my code.

#include<iostream>
using namespace std;
// program Objective: To write a nested structure.  

struct Mystruct // nested structure where Mystruct1 is embedded in the first structure Mystruct.
{
int x;
int y;

};

struct Mystruct1
 {
  int x1;
  int y1;
  int z1;
  }; // no semicolon needed here since it is a nested structure.


int main()
{


Mystruct S; // create a instance.

S.x.x1 = 5; // a error on this line maybe syntax problem?
cout << "The first combined element is " << S.x.x1 << endl;


Answer
Well reading the _code_ posted in your question and not the comments shows no nesting of struct definitions nor of struct instance members between Mystruct and Mystruct1 - both struct definitions appear to be within the same namespace - the global namespace - and independent of each other.

These are the definitions I received in your question:

   struct Mystruct
   {
       int x;
       int y;
   };

   struct Mystruct1
   {
       int x1;
       int y1;
       int z1;
   };

Is this really what you intended to post in your question?

If not then please post a followup showing the code you intended to post, if my comments below do not cover what you are having problems with.

Before getting into nesting of class types (classes, structs and unions) I would like to say something about the second comment in the posted code:

   // no semicolon needed here since it is a nested structure.

This is _not_ true in C and C++. In C and C++ struct, union (and class for C++) definitions are _always_ terminated with a semicolon.They may optionally be followed by object or data member names:

   struct Point
   {
       int x;
       int y;
   } a_point, another_point;

Which is not a very common style in modern C++, but probably explains the reason behind the requirement for a semicolon - note that the newer C++ feature of namespaces do not require a semicolon when they are closed:

   namespace MyNamingspace
   {

       ...

   }

Probably because you cannot have named instances (i.e. objects) of namespaces.

Now onto nesting of types.

We can nest a struct class or union definition within another class struct or union definition like so:

   struct Mystruct
   {
       struct Mystruct1
       {
           int x1;
           int y1;
           int z1;
       };      // Semicolon required even for nested type definitions
               // (try removing it and see what the compiler has to say about it!)

       int x;
       int y;
   };

However this does _not_ mean that each instance of MyStruct contains an instance of the inner Mystruct1 struct. All it means is that the definition of Mystruct1 is within the namespace of the outer Mystruct definition and so has to be referred to using a qualified name outside of Mystruct:

   int main()
   {
       Mystruct S; // S contains an x and a y member, both of type int
       S.x = 1;
       S.y = 2;

       Mystruct::Mystruct1 S1; // S1 contains an x1, a y1 and a z1 member, all of type int
       S1.x1 = 10;
       S1.y1 = 20;
       S1.z1 = 30;
   }

To get actual instances of type Mystruct::Mystruct1 as members of Mystruct instances we have to explicitly define data members for this type:

   struct Mystruct
   {
       struct Mystruct1
       {
           int x1;
           int y1;
           int z1;
       };

       Mystruct1 s;
       int x;
       int y;
   };

Now we have a MyStruct definition which contains a Mystruct::Mystruct1 member called s, so now we can write:

   int main()
   {
       Mystruct S; // S now contains an s member of type Mystruct::Mystruct1
                   // and an x and a y member, both of type int
       S.x = 1;
       S.y = 2;

       S.s.x1 = 10;
       S.s.y1 = 20;
       S.s.z1 = 30;
   }

Notice that within Mystruct we can refer to Mystruct::Mystruct1 unqualified as just Mystruct1 as it is within the namespace scope of Mystruct. We could also have defined s before the semicolon terminating the definition of Mystruct::Mystruct1:

   struct Mystruct
   {
       struct Mystruct1
       {
           int x1;
           int y1;
           int z1;
       } s;

       int x;
       int y;
   };

Hope this clarifies nesting of class types and using data members of a class type that are instances of other class types - whose definitions may or may not be nested within the type defining the data members.