Struct declaration - cppreference.com (2024)

A struct is a type consisting of a sequence of members whose storage is allocated in an ordered sequence (as opposed to union, which is a type consisting of a sequence of members whose storage overlaps).

The type specifier for a struct is identical to the union type specifier except for the keyword used:

[edit] Syntax

1) Struct definition: introduces the new type struct name and defines its meaning

2) If used on a line of its own, as in struct name ;, declares but doesn't define the struct name (see forward declaration below). In other contexts, names the previously-declared struct, and attr-spec-seq is not allowed.

[edit] Explanation

Within a struct object, addresses of its elements (and the addresses of the bit-field allocation units) increase in order in which the members were defined. A pointer to a struct can be cast to a pointer to its first member (or, if the member is a bit-field, to its allocation unit). Likewise, a pointer to the first member of a struct can be cast to a pointer to the enclosing struct. There may be unnamed padding between any two members of a struct or after the last member, but not before the first member. The size of a struct is at least as large as the sum of the sizes of its members.

struct s { int n; double d[]; }; // s.d is a flexible array memberstruct s t1 = { 0 }; // OK, d is as if double d[1], but UB to accessstruct s t2 = { 1, { 4.2 } }; // error: initialization ignores flexible array// if sizeof (double) == 8struct s *s1 = malloc(sizeof (struct s) + 64); // as if d was double d[8]struct s *s2 = malloc(sizeof (struct s) + 40); // as if d was double d[5]s1 = malloc(sizeof (struct s) + 10); // now as if d was double d[1]. Two bytes excess.double *dp = &(s1->d[0]); // OK*dp = 42; // OKs1->d[1]++; // Undefined behavior. 2 excess bytes can't be accessed // as double.s2 = malloc(sizeof (struct s) + 6); // same, but UB to access because 2 bytes are // missing to complete 1 doubledp = &(s2->d[0]); // OK, can take address just fine*dp = 42; // undefined behavior*s1 = *s2; // only copies s.n, not any element of s.d // except those caught in sizeof (struct s)

struct v{ union // anonymous union { struct { int i, j; }; // anonymous structure struct { long k, l; } w; }; int m;} v1;v1.i = 2; // validv1.k = 3; // invalid: inner structure is not anonymousv1.w.k = 5; // valid

[edit] Forward declaration

A declaration of the following form

hides any previously declared meaning for the name name in the tag name space and declares name as a new struct name in current scope, which will be defined later. Until the definition appears, this struct name has incomplete type.

This allows structs that refer to each other:

struct y;struct x { struct y *p; /* ... */ };struct y { struct x *q; /* ... */ };

Note that a new struct name may also be introduced just by using a struct tag within another declaration, but if a previously declared struct with the same name exists in the tag name space, the tag would refer to that name

struct s* p = NULL; // tag naming an unknown struct declares itstruct s { int a; }; // definition for the struct pointed to by pvoid g(void){ struct s; // forward declaration of a new, local struct s // this hides global struct s until the end of this block struct s *p; // pointer to local struct s // without the forward declaration above, // this would point at the file-scope s struct s { char* p; }; // definitions of the local struct s}

[edit] Keywords

struct

[edit] Notes

See struct initialization for the rules regarding the initializers for structs.

Because members of incomplete type are not allowed, and a struct type is not complete until the end of the definition, a struct cannot have a member of its own type. A pointer to its own type is allowed, and is commonly used to implement nodes in linked lists or trees.

Because a struct declaration does not establish scope, nested types, enumerations and enumerators introduced by declarations within struct-declaration-list are visible in the surrounding scope where the struct is defined.

[edit] Example

#include <stddef.h>#include <stdio.h>int main(void){ // Declare the struct type. struct car { char* make; int year; }; // Declare and initialize an object of a previously-declared struct type. struct car c = {.year = 1923, .make = "Nash"}; printf("1) Car:%d%s\n", c.year, c.make); // Declare a struct type, an object of that type, and a pointer to it. struct spaceship { char* model; int max_speed; } ship = {"T-65 X-wing starfighter", 1050}, *pship = &ship; printf("2) Spaceship:%s. Max speed:%d km/h\n\n", ship.model, ship.max_speed); // Address increase in order of definition. Padding may be inserted. struct A { char a; double b; char c; }; printf( "3) Offset of char a =%zu\n" "4) Offset of double b =%zu\n" "5) Offset of char c =%zu\n" "6) Size of struct A =%zu\n\n", offsetof(struct A, a), offsetof(struct A, b), offsetof(struct A, c), sizeof(struct A) ); struct B { char a; char b; double c; }; printf( "7) Offset of char a =%zu\n" "8) Offset of char b =%zu\n" "9) Offset of double c =%zu\n" "A) Size of struct B =%zu\n\n", offsetof(struct B, a), offsetof(struct B, b), offsetof(struct B, c), sizeof(struct B) ); // A pointer to a struct can be cast to a pointer // to its first member and vice versa. char** pmodel = (char **)pship; printf("B)%s\n", *pmodel); pship = (struct spaceship *)pmodel;}

1) Car: 1923 Nash2) Spaceship: T-65 X-wing starfighter. Max speed: 1050 km/h3) Offset of char a = 04) Offset of double b = 85) Offset of char c = 166) Size of struct A = 247) Offset of char a = 08) Offset of char b = 19) Offset of double c = 8A) Size of struct B = 16B) T-65 X-wing starfighter

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C standards.

[edit] References

[edit] See also

• struct and union member access
• bit-field
• struct initialization