Scribd
Upload
3 views

Functions and Structures: Structures Cheatsheet

The document provides an overview of defining and using structures in C programming, including how to declare, initialize, and access member variables. It explains the use of dot and arrow notation for accessing structure members, as well as passing structures and structure pointers to functions. Additionally, it highlights the flexibility of structures in grouping different data types to model complex data accurately.

Uploaded by

Duarte Almeida
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
3 views

Functions and Structures: Structures Cheatsheet

The document provides an overview of defining and using structures in C programming, including how to declare, initialize, and access member variables. It explains the use of dot and arrow notation for accessing structure members, as well as passing structures and structure pointers to functions. Additionally, it highlights the flexibility of structures in grouping different data types to model complex data accurately.

Uploaded by

Duarte Almeida
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Cheatsheets / Learn C: Functions and Structures

Structures

De!ning Structures With struct


struct

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

Initializing Structures With struct


struct

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

// 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};
Custom Data Types With Structures

Structures allow the de!nition of custom data


types that are used to represent complex data.
Structure customization provides the "exibility to
accurately model real-world data, giving you the
ability to access and modify the data from a single
de!ned variable.

Grouping Data Types With Structures

Structures can group di#erent data types together // `Person` structure definition
into a single, user-de!ned type. This di#ers from
arrays which can only group the same data type
struct Person{
together into a single type. The given code block // member variables that vary in
de!nes a structure named Person with type
di#erent basic data types as member variables.
char* name;
int age;
char middleInitial;
};
Accessing Member Variables With Dot Notation

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


accessed with the dot ( . ) operator. The given
struct Person{
code block initializes a Person type named
person1 and accesses the name member // member variables
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

Structure Member Variables

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

Pointers to a structure can be de!ned using the // Person structure declaration


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

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

// person1Pointer initializated to the


memory address of person1
struct Person* person1Pointer =
&person1;
Accessing Member Variables With Arrow Notiation

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


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

// `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 // Person structure declaration


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

// declaring Person type parameter


void myFunc(struct Person person1);
Passing Structure Pointers To Functions

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


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

// Person pointer parameter


declaration
void myFunc(struct Person*
person1Pointer);

Print Share

You might also like