16/05/2024, 21:50 Learn C: Functions and Structures: Structures Cheatsheet | Codecademy

Cheatsheets / Learn C: Functions and Structures

Structures

Defining Structures With struct

Structures are defined with the struct keyword // `struct` keyword and structure name
followed by the structure name. Inside the braces,
struct Person{
member variables are declared but not initialized. The
given code block defines a structure named Person // uninitialized member variables
with declared member variables name and age . char* name;
int age;
};

Initializing Structures With struct

Structure data types are initialized using the struct // `Person` structure declaration
keyword with the defined structure type followed by
struct Person{
the name of the variable. The given code block shows
two ways to initialize Person type structures named
char* name;
person1 and person2 . int age;
};

// designated initialization with member

variable names
struct Person person1 = {.name = "Cosmo",
.age = 36};

// implicit initialization following order

of member variables
struct Person person2 = {"George", 29};

https://www.codecademy.com/learn/learn-c-functions-and-structures/modules/structures-c-next-steps/cheatsheet 1/5
16/05/2024, 21:50 Learn C: Functions and Structures: Structures Cheatsheet | Codecademy

Custom Data Types With Structures

Structures allow the definition of custom data types

that are used to represent complex data. Structure
customization provides the flexibility to accurately
model real-world data, giving you the ability to access
and modify the data from a single defined variable.

Grouping Data Types With Structures

Structures can group different data types together into // `Person` structure definition
a single, user-defined type. This differs from arrays
struct Person{
which can only group the same data type together into
a single type. The given code block defines a structure // member variables that vary in type
named Person with different basic data types as char* name;
member variables.
int age;
char middleInitial;
};

Accessing Member Variables With Dot Notation

Initialized structure member variables can be accessed // `Person` structure declaration

with the dot ( . ) operator. The given code block
struct Person{
initializes a Person type named person1 and
// member variables
accesses the name member variable within a
printf() statement. char* name;
int age;
char middleInitial;
};

// initialization of `person1`
struct Person person1 = {.name = "George",
.age = 28, .middleInitial = "C"};

// accessing `name` in `person1`

printf("My name is %s", person1.name);
// OUTPUT: My name is George

https://www.codecademy.com/learn/learn-c-functions-and-structures/modules/structures-c-next-steps/cheatsheet 2/5
16/05/2024, 21:50 Learn C: Functions and Structures: Structures Cheatsheet | Codecademy

Structure Member Variables

The variables defined within a structure are known as // Person structure declaration
member variables. The given code block defined a
struct Person{
structure named Person with member variables
name of type char* , and age of type int . // member variables
char* name;
int age;
};

Structure Type Pointers

Pointers to a structure can be defined using the struct // Person structure declaration
keyword, the structure type, and the pointer ( * ) struct Person{
symbol. The memory address of an initialized structure
// member variables
can be accessed using the symbol ( & ). The given code
block defines a pointer to a Person data type named char* name;
person1 . int age;
};

// person1 initialization
struct Person person1 = {"George", 28};

// person1Pointer initializated to the

memory address of person1
struct Person* person1Pointer = &person1;

https://www.codecademy.com/learn/learn-c-functions-and-structures/modules/structures-c-next-steps/cheatsheet 3/5
16/05/2024, 21:50 Learn C: Functions and Structures: Structures Cheatsheet | Codecademy

Accessing Member Variables With Arrow Notiation

Member variables of a structure can be accessed using // `Person` structure declaration

a pointer with arrow ( -> ) notation. The given code
struct Person{
block initializes a Person pointer type named
// member variables
person1Pointer . Inside the printf() statement, the
name member variable of person1 is accessed using char* name;
arrow ( -> ) notation. int age;
};

// `person1` intialization
struct Person person1 = {"Jerry", 29};

// `person1Pointer` intialization to memory

address to `person1`
struct Person* person1Pointer = &person1;

// accessing `name` through

`person1Pointer`
printf("My name is %s", person1Pointer-
>name);
// OUTPUT: My name is Jerry

Passing Structures To Functions

Structures can be used as parameters of functions by // Person structure declaration

using the struct keyword followed by the structure
struct Person{
name in the function definition. The given code block
defines a function signature named myFunc() with a // member variables
Person parameter named person1 . char* name;
int age;
};

// declaring Person type parameter

void myFunc(struct Person person1);

https://www.codecademy.com/learn/learn-c-functions-and-structures/modules/structures-c-next-steps/cheatsheet 4/5
16/05/2024, 21:50 Learn C: Functions and Structures: Structures Cheatsheet | Codecademy

Passing Structure Pointers To Functions

Structure pointers can be paramters of functions by // Person structure declaration

using the struct keyword, the structure name, and the
struct Person{
pointer symbol ( * ) in the function definition. The given
code block defines a function signature named // member variables
myFunc() with a Person pointer parameter named char* name;
person1Pointer . int age;
};

// Person pointer parameter declaration

void myFunc(struct Person* person1Pointer);

Print Share

https://www.codecademy.com/learn/learn-c-functions-and-structures/modules/structures-c-next-steps/cheatsheet 5/5