A struct in the C programming language (and many derivatives) is a complex data type declaration

that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).
The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length
boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is
implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]
In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.
A struct in the C programming language (and many derivatives) is a complex data type declaration
that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).
The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length

boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is
implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]
In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.
A struct in the C programming language (and many derivatives) is a complex data type declaration
that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).
The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length
boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is
implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]

In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.
A struct in the C programming language (and many derivatives) is a complex data type declaration
that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).
The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length
boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is
implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]
In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.
A struct in the C programming language (and many derivatives) is a complex data type declaration
that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).

The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length
boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is
implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]
In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.
A struct in the C programming language (and many derivatives) is a complex data type declaration
that defines a physically grouped list of variables to be placed under one name in a block of memory,
allowing the different variables to be accessed via a single pointer, or the struct declared name
which returns the same address. The struct can contain many other complex and simple data types
in an association, so is a natural organizing type for records like the mixed data types in lists of
directory entries reading a hard drive (file length, name, extension, physical (cylinder, disk, head
indexes) address, etc.), or other mixed record type (patient names, address, telephone... insurance
codes, balance, etc.).
The C struct directly corresponds to the Assembly Language data type of the same use, and both
reference a contiguous block of physical memory, usually delimited (sized) by word-length
boundaries. Language implementations which could utilize half-word or byte boundaries (giving
denser packing, using less memory) were considered advanced in the mid-eighties. Being a block of
contiguous memory, each variable within is located a fixed offset from the index zero reference, the
pointer. As an illustration, many BASIC interpreters once fielded a string data struct organization with
one value recording string length, one indexing (cursor value of) the previous line, one pointing the
string data.
Because the contents of a struct are stored in contiguous memory, the sizeof operator must be used
to get the number of bytes needed to store a particular type of struct, just as it can be used for
primitives. The alignment of particular fields in the struct (with respect to word boundaries) is

implementation-specific and may include padding, although modern compilers typically support
the #pragma pack directive, which changes the size in bytes used for alignment.[1]
In the C++ language, a struct is identical to a C++ class but a difference in the default visibility exists:
class members are by default private, whereas struct members are by default public.