Learn about "packaging" data with structures in C.

Structures: Lesson

Now that we’ve leveraged that power of structures to package variables together we can discuss how we can access each member variable individually using _dot notation_.

Dot notation is a C operator that allows you to access and modify a member variable of a structure.
```c
struct Bottle {
  char* name;
  int maxCapacity;
  int currentCapacity;
};

struct Bottle myBottle = {"Medium Bottle", 24, 0};

// Fill some of myBottle
myBottle.currentCapacity = 10;
printf("The bottle is now filled to %d", myBottle.currentCapacity);
``` 
In the example above:
- A bottle structure is defined and initialized with the variable `myBottle`
- The member variable `currentCapacity` is accessed and set to `10` with `myBottle.currentCapacity = 10`
- The same variable is accessed again using the dot operator and output with `printf()`  

You can also use the dot operator to initialize a structure if you’d like to declare it first without initializing it right away like:
```c
struct Bottle myBottle;
myBottle.name = "Medium Bottle";
myBottle.maxCapacity = 24;
myBottle.currentCapacity = 0;
```
The dot operator is essential in enhancing the packaging benefits of structs by allowing you to access any of the `Bottle` member variables through the variable `myBottle`.


Structure Dot Notation

Great job learning about structures! We’ve covered many important topics:
- Structures allow you to create user-defined data types
- Structures can package together other data types into one type
- You can define a structure using the `struct` keyword 
- When defining a structure, the member variables are declared but not instantiated
- Structures help programs work with complex data and can represent real-world objects
- You can access member variables with the dot operator
- You can have a pointer to a structure and access its member variables using the arrow operator
- You can pass structures and structure pointers to functions
- You can return structures from functions

With our understanding of structures, we can now create and work with complicated data types easily and efficiently. 


Summary

To help us understand how to include structures (also called structs) in our code, let's look at how to define them:

![Structure components, the keyword struct, the name Bottle and member variables declare inside curly braces](https://static-assets.codecademy.com/Courses/learn-c/structures/Structure-Definition.svg)

In the image above:
- The `struct` keyword initiates the structure type definition
- `Bottle` is the name of the new structure type 
- A set of curly braces, `{}`, to enclose the struct member variables
- Inside the braces, the member variables are "packaged" together. 

Member variables can be any basic types (`int`, `char`, etc). They can also be derived types like arrays, pointers, and even other structures. It's important to note that the member variables should only be declared and not initialized (we will learn about this later). Attempting to give the member variable values will lead to an error. 

Defining Structures

Now that we know how to define structures, let's take a look at how we can use them in our code.
```c
struct Bottle {
  char* name;
  int maxCapacity;
  int currentCapacity;
};

struct Bottle bottle1 = {"superBottle", 24, 0};
```
The above example defines the struct `Bottle` from the last exercise. The last line of the code then initializes a struct using an ordered notation: 
- The `struct` keyword - once again
- The user-defined struct type, `Bottle` 
- The name of the structure variable, `bottle1`
- The member variable value assignments within a set of curly braces, `{}`

The order of values assigned to the member variables match the order in which the variables were defined in the structure. 

If you wish to be more specific with your initialization and not worry about putting elements in the right order you can do it using an unordered notation:
```c
struct Bottle bottle1 = {
  .maxCapacity = 24,
  .name = "superBottle",
  .currentCapacity = 0
};
```
Once initialized, structures allow you to work with complex data types in a more cohesive and efficient manner. 

Initializing Structures

Throughout this course, we have defined many different variable types like, `int` and `char`. These are known as the basic types and are built-in to C. 

We’ve also defined data types like arrays and pointers which are known as derived types. Derived types tend to be a collection of basic types to create a new, more powerful data type. We will now explore another derived type, _the structure_. 

In C, structures allow programmers to create user-defined data types. Structures, like arrays, allow you to collect many data types into one single data type. But unlike arrays, structures can be a collection of multiple data types. 

![A group of different types of variables inside a structure.](https://static-assets.codecademy.com/Courses/learn-c/structures/Structure-Intro.svg)

The above image represents a structure and the different types of variables contained within it. This type of "packaging" is beneficial because it helps build and pass around logically related data in a single user-defined data type.


Introduction

Similar to other derived types, like arrays and strings, structures can use a lot of memory. Imagine a structure with multiple strings each able to hold hundreds of characters. 

One way to manage memory while working on data types of this size is to use pointers. As a reminder, a pointer is a variable that holds the memory address to another variable. 

For structures, this is accomplished by first defining the structure variable, then defining a pointer and assigning it the address to the structure variable. 
```c
struct Bottle myBottle = {"Medium Bottle", 24, 0};
struct Bottle* bottlePointer = &myBottle;
```
In the above example, `bottlePointer` holds the memory address pointing to `myBottle`.

To access member variables with `bottlePointer` and the dot operator we can use the following syntax:
```c
(*bottlePointer).name;
(*bottlePointer).maxCapacity;
(*bottlePointer).currentCapacity;
```
When using pointers we need to dereference, `*`, the address to access the variable it points to. When using the dot operator with structure pointers, we also need to wrap the dereference in parenthesis, `()`. If we simply dereference like `*aPointer.name`, it will result in an error.

Arrow notation can also be used with pointers to structures, as it implicitly does the dereferencing for you. 
```c
aPointer->name;
aPointer->maxCapacity;
aPointer->currentCapacity;
```
Notice how much better the arrow notation reads compared to dot notation.  This notation is a clear and simple way to work with user-defined structure pointers. 


Structure Pointers

Let's now take a step back and discuss why we would want to use structures. Look at an example of a program that uses bottle data without structures.
```c
char bottleName1[]  = "Medium Bottle";
int maxCapacity1 = 24;
int currentCapcity1 = 0;

char bottleName2[]  = "Large Bottle";
int maxCapacity2 = 48;
int currentCapcity2 = 20;
```
Notice that we need to keep track of six variables while working with this bottle data. As we increase the number of bottles, the number of variables would increase by 3 per bottle. This approach can get extremely unmaintainable. 

In a small number of situations, we could possibly use arrays. But that's only when the data is the same type, so this isn't useful all the time.

```c
struct Bottle {
  char* name;
  int maxCapacity;
  int currentCapacity;
};

struct Bottle bottle1 = {"Medium Bottle", 24, 0};
struct Bottle bottle2 = {"Large Bottle", 48, 20};
```
Using a struct to encapsulate all the members that represent a `Bottle` we can:
1. Reduce complexity by representing a set of data with one variable
2. Package different, but logically similar, data together
3. Better represent real-world "things" into data types

Being able to represent data using structures is extremely beneficial as you continue working on more complex real-world problems.

Why Use Structures

Let's wrap up by using structures with functions.

We can specify structures and pointers to structures as parameters to functions:
```c
void myFunction(struct Bottle b, struct Bottle* bPointer)
```
When passing a structure to a function:
- A copy of the structure is made so memory usage is a concern
- Any modifications made to the structure will not affect the original structure, only the copy

When passing a pointer to a structure:
- Because the pointer is the address of the original structure any modifications to the member variables will affect the original structure

```c
void bottleFunction(struct Bottle b, struct Bottle* bPointer){
  b.name = "Super Large";
  b.maxCapacity = 100;
  bPointer->name = "Super Small";
  bPointer->maxCapacity = 4;	
}

int main(){
  struct Bottle b1 = {"Medium", 24, 9};
  struct Bottle b2 = {"Large", 35, 9};

  bottleFunction(b1, &b2);
}
```
In the above example:
- `bottleFunction` has 2 parameters, a `Bottle` structure and a pointer to a `Bottle` structure
- Inside the function, the structures are accessed the same as they would whether it is a structure or pointer to a structure.
- The first argument in the call to `bottleFunction()` inside `main()` is `b1`. A copy of this structure is made within `bottleFunction()` and no changes can be made to the values of `b1` in `main()`
- The second argument in the call to `bottleFunction()` is `&b2`: the address of `b2`. Any change to the member variables using this address will change the values of `b2` in `main()`

We can also return structures by setting the return type in the function signature:
```c
struct Bottle getEmptyBottle(void){
  struct Bottle b = {"My Bottle", 24, 0};
  return b;
}
```
Notice that structures as parameters and as the return type must use the `struct` keyword. 