What does the following struct definition mean?

Question

In a few places in the code I have a struct definition that looks like this:

typedef struct tagNameOfStruct{
  //some methods and members
}T_NameOfStruct, * PT_NameOfStruct, FAR LPT_NameOfStruct;

typedef struct tagNameOfStructLists{
  //some methods and members
}T_NameOfStructLists, * PT_NameOfStructLists, FAR LPT_NameOfStructLists;
 typedef pair<T_NameOfStruct, T_NameOfStructLists> CStructPair;
 typedef map<T_NameOfStruct, T_NameOfStructLists> CStructMap;

Than I see that inside a method within a loop the following line of code

T_NameOfStruct instance;
T_NameOfStructLists listInstance;
m_MapInstance.insert(CStructPair(instance, listInstance));
//structMapInstance is a members of method class of type CStructMap

That instance is being inserted to data-structure which is used outside the scope of the function.It is passed to the data-structure by reference.

1. Shouldn't instance die when we leave the function scope?
2. What does the last line of the struct definition mean?

Edit ---- Why this is not a duplicate, please reopen---- : The * PT_NameOfStruct, FAR LPT_NameOfStruct in the struct definition are different from the question you guys linked too. Also there is the issue of the passing the instance by ref while it is defines on the method stack. The strange thing is that the code works so I'm wondering what I'm missing here. Why don't I get an exception while trying to access destroyed objects in a different function which iterates over the data structure. Still think it's a duplicate?

Answer 1

Shouldn't instance die when we leave the function scope?

Yes. If the code you haven't shown us actually uses a reference to it after that, then it's wrong. But since we can't see it, we can only guess whether or not it does that.

UPDATE: Now you've shown us what's actually happening, it's being passed to map::insert, which stores a copy of its argument (even though it takes the argument by reference). There's no problem when instance itself is destroyed, assuming it has valid copy semantics.

What does the ending of the struct definition mean?

It declares:

• a class called tagNameOfStruct.
• an alias for the class type, called T_NameOfStruct. In C++ this is completely pointless; in C, some people have a bad habit of doing that to avoid typing struct when specifying the type.
• an alias for a pointer to the type, called PT_NameOfStruct. This is an even worse idea than the first typedef, since it hides the important information that something is a pointer.
• an alias for an obsolete "far" pointer to the type, called LPT_NameOfStruct. That's a hangover from 16-bit platforms; on a modern platform it will be the same as the regular pointer type.

Don't use this as a model for how to declare class types. It's better to keep it simple:

class NameOfStruct {  // or "struct", if you want members to be public by default
    // members
};

NameOfStruct instance;  // No need for a typedef
NameOfStruct * pointer; // Make it clear that it's a pointer

Answer 2

struct tagNameOfStruct{

In C++, struct tags have equivalent status to typedefs. Not so in C.

T_NameOfStruct

This is another and better name for tagNameOfStruct.

*PT_NameOfStruct

This is a typedef for a pointer to NameOfStruct.

FAR LPT_NameOfStruct;

This is an obsolete name for a FAR pointer to NameOfStruct, given that near and far pointers have meant the same thing since Windows 95 as far as I can see. Note that this is because of the preceding * in the preceding typename, which carries over to this one because of C's strange pointer syntax.

The only things you need to worry about here are NameOfStruct, which is a typedef for the struct itself, and PT_NameOfStruct, which is a pointer to it. The rest is fluff.

That instance is being inserted to data-structure which is used outside the scope of the function. It is passed to the data-structure by reference.

Shouldn't instance die when we leave the function scope?

Yes. You have found a bug.

What does the ending of the struct definition mean?

'The ending of the struct definition' means that this is the end of the struct definition. What else would it mean? Did you mean the ending of the declaration? Did you mean everything I've stated above?

Answer 3

In addition to the above answers,

struct s
{

}

In above struct definition you can use as follows

in c for declaring instance you should do like this

struct s instance1;

in c++ you should define as follows

struct s instance1; (or)
s instance1;

Both are valid in c++.

In c instead of using struct s at all area you can use typedef for simplification.