Is it possible to create a struct inside the same uncreated struct?

Question

Is the following declaration possible? If so, how do you access the elements inside the struct? It compiles but I cannot access the elements.

struct node
{
    int a;
    struct node *next;
};
struct node *node1;
int main()
{
    node1->a = 5; // I cannot perform this operation
    return 0;
}

That's a typical structure layout for a pretty common and standard single-linked list. You access the members like you do any other structure. — Some programmer dude, Feb 13 '18 at 07:48
The `node *` is probably better understood as creating a pointer inside a `struct`. — Niall, Feb 13 '18 at 07:51
what do you mean with "i cannot access the elements" ? There is no attempt of accessing elements in the code you show here. Please show what you tried and the error messages you get. See also: [mcve] — 463035818_is_not_an_ai, Feb 13 '18 at 07:52
By the way in C++ you don't need to write `struct node *` just `node*` is fine (it's different from C in that regard). Though ideally you'd use a smart pointer instead of a raw pointer — UnholySheep, Feb 13 '18 at 07:52
In fact in C++ you should be using [containers](http://en.cppreference.com/w/cpp/container) and leave this _struct wiring_ to academia and bad C++ interviewers. — Ron, Feb 13 '18 at 07:54
@Ron I dont agree in this generality. I write simple containers on a daily basis for stuff that I could as well put inside a `std::pair`. — 463035818_is_not_an_ai, Feb 13 '18 at 07:55
@George `first` and `second` are rarely meaningful names. `std::pair` is good for generic code where you have no better names, but if I can name my members then I do it — 463035818_is_not_an_ai, Feb 13 '18 at 07:57
@user463035818 You can always combine containers and smart pointers to produce the storage class of your own. — Ron, Feb 13 '18 at 08:08

Niall · Answer 1 · 2018-02-13T11:42:03.067

Based on your MCVE, you don't create the node, you have an uninitialised pointer. The node* next seems to be a red herring to your current problem.

struct node
{
    int a;
    node *next; // seems to be a red herring to your current problem.
};

int main()
{
    node node1; // <-- for this demo, create it on the stack
    node1.a = 5;
    return 0;
}

Note; the node * is probably better understood as creating a pointer to a structure of the same type inside a struct (which is allowed), not so much a "struct in an uncreated struct".

moooeeeep · Accepted Answer · 2018-02-14T07:33:13.717

I think you need to review the basics of the language. So maybe a link to the booklist is in order:

The Definitive C++ Book Guide and List

To address your questions:

Here you define a type, i.e., a struct named node, as containing an object of type int and an object of type pointer to an object of type node (struct node*):

struct node
{
    int a;
    struct node *next;
};

Here you declare a global object of type pointer to an object of type node:

struct node *node1;

Note that pointers are invalid by default, that is, they don't point to an object automatically.

So you have a pointer, but you don't actually have an object of type node. Therefore you are not allowed to dereference the pointer. It is forbidden to access the (arbitrary) memory location the pointer currently happens to point at.

int main()
{
    node1->a = 5; // It is forbidden to perform this operation
    return 0;
}

In order to fix this. You need to create an object and let the pointer point to it.

Example:

int main() {
    node n; // create an object of type node
    node1 = &n; // Assign the address of the object n to the pointer
    node1->a = 5; // Now it's allowed to dereference the pointer
}

And finally:

Is it possible to create a struct inside the same uncreated struct?

You can have a type that contains pointers to objects of the same type. This can be useful to implement recursive data structures, e.g., linked lists or trees.

For further reading:

score 1 · Answer 3 · answered Feb 13 '18 at 08:01

You cannot access fields because you created just a pointer, to a struct instance, but not the last one. Accessing elements thw way like this is an undefined behavior. To make it correct, you should write for example

struct node *node1;
int main()
{
    node1 = new node();
    node1->a = 5; // now ok
    node1->next = new node(); // again, before this we had an unitialized ptr.
    return 0;
}

The other question that it isn't a very efficient way in this context.

Is it possible to create a struct inside the same uncreated struct?

3 Answers3