Structures in C

1. Defining and Declaring Structures

A structure in C is a user-defined data type that allows grouping variables of

different data types under a single name.

#include <stdio.h>
#include <string.h>

// Define structure
struct Person {
char name[50];
int age;
float height;
};

int main() {
// Declare structure variable
struct Person p1;

// Assign values
p1.age = 25;
p1.height = 5.9;
strcpy(p1.name, "Alice");

// Access values
printf("Name: %s\n", p1.name);
printf("Age: %d\n", p1.age);
printf("Height: %.1f\n", p1.height);
return 0;
}

Output:

Name: Alice
Age: 25
Height: 5.9

2. Accessing Members Using . and -> Operators

• . is used with structure variables.

• -> is used with structure pointers.

#include <stdio.h>
struct Point {
int x, y;
};

int main() {
struct Point p = {10, 20};
struct Point *ptr = &p;

// Using dot operator

printf("x: %d, y: %d\n", p.x, p.y);

// Using arrow operator

printf("x: %d, y: %d\n", ptr->x, ptr->y);
return 0;
}

Output:

x: 10, y: 20
x: 10, y: 20

3. Array of Structures

#include <stdio.h>
struct Student {
int id;
char name[50];
};

int main() {
struct Student s[2] = {
{1, "John"},
{2, "Emma"}
};

for (int i = 0; i < 2; i++) {

printf("ID: %d, Name: %s\n", s[i].id,
s[i].name);
}
return 0;
}
Output:

ID: 1, Name: John

ID: 2, Name: Emma

4. Nested Structures

#include <stdio.h>
#include <string.h>
struct Address {
char city[20];
int pincode;
};

struct Employee {
char name[50];
struct Address addr;
};

int main() {
struct Employee emp;
strcpy(emp.name, "Alice");
strcpy(emp.addr.city, "Mumbai");
emp.addr.pincode = 400001;

printf("Name: %s\n", emp.name);

printf("City: %s\n", emp.addr.city);
printf("Pincode: %d\n", emp.addr.pincode);
return 0;
}

Output:

Name: Alice
City: Mumbai
Pincode: 400001

5. Structure Padding

Structure padding is the addition of empty bytes to align data members according
to the system architecture.

#include <stdio.h>
struct A {
char c;
int i;
};

int main() {
printf("Size of structure A: %lu\n", sizeof(struct
A));
return 0;
}

Output (may vary):

Size of structure A: 8
Unions in C

1. Defining and Using Unions

A union is like a structure but uses shared memory for all members.

#include <stdio.h>
#include <string.h>
union Data {
int i;
float f;
char str[20];
};

int main() {
union Data data;

data.i = 10;
printf("data.i: %d\n", data.i);

data.f = 220.5;
printf("data.f: %.1f\n", data.f); // Overwrites i

strcpy(data.str, "Hello");
printf("data.str: %s\n", data.str); // Overwrites f

return 0;
}
Output:

data.i: 10
data.f: 220.5
data.str: Hello

2. Difference Between Structure and Union

Feature Structure Union

Memory Allocates memory for all members Shares memory for all members
Size Sum of all members' sizes Size of the largest member
Usage Use all members independently One member at a time

Enumerations in C

1. Defining Enums Using enum Keyword

An enum is a user-defined data type consisting of integral constants.

#include <stdio.h>

enum Color {RED, GREEN, BLUE};

int main() {
enum Color c;
c = GREEN;

printf("Color code: %d\n", c); // Outputs 1

return 0;
}

Output:

Color code: 1

2. Accessing Enum Values

You can directly use the enum names.

#include <stdio.h>

enum Days {MON, TUE, WED, THU, FRI, SAT, SUN};

int main() {
enum Days today = FRI;
if (today == FRI) {
printf("Weekend is near!\n");
}
return 0;
}

Output:

Weekend is near!

3. Custom Starting Values

#include <stdio.h>
enum Level {LOW = 10, MEDIUM = 20, HIGH = 30};

int main() {
enum Level l = MEDIUM;
printf("Level value: %d\n", l);
return 0;
}

Output:

Level value: 20

4. Importance of Enums

• Improve code readability

• Restrict variable to hold only certain values
• Useful in switch-case
Structures in C

1. Defining and Declaring Structures

Name: Alice
Age: 25
Height: 5.9
2. Accessing Members Using . and -> Operators
x: 10, y: 20
x: 10, y: 20
3. Array of Structures
ID: 1, Name: John
ID: 2, Name: Emma
4. Nested Structures
Name: Alice
City: Mumbai
Pincode: 400001
5. Structure Padding

(Output will vary by system, typically 8 on 64-bit systems due to padding)

Size of structure A: 8

Unions in C

1. Defining and Using Unions

data.i: 10
data.f: 220.5
data.str: Hello

Note: Each assignment overwrites the previous one because all members share the
same memory.

2. Difference Table — Output not needed (it's a reference table).

Enumerations in C

1. Defining Enums Using enum Keyword

Color code: 1
2. Accessing Enum Values
Weekend is near!
3. Custom Starting Values
Level value: 20
🧠 Structure Padding vs Packing in C

Structure Padding

Padding is extra bytes the compiler adds between members to align them for faster
access (depending on CPU architecture).

#include <stdio.h>

struct Padded {
char a; // 1 byte
// 3 bytes padding
int b; // 4 bytes
};

int main() {
printf("Size of struct Padded: %lu\n",
sizeof(struct Padded)); // Output: 8 on most 32-bit or
64-bit systems
return 0;
}

Why? After char a, 3 empty bytes are added to align int b to a 4-byte
boundary.
Structure Packing

Packing avoids padding to save memory. It uses #pragma pack(1).

#include <stdio.h>
#pragma pack(1)

struct Packed {
char a; // 1 byte
int b; // 4 bytes
};

int main() {
printf("Size of struct Packed: %lu\n",
sizeof(struct Packed)); // Output: 5
return 0;
}

Note: Accessing packed members can be slower due to misalignment.

Padding vs Packing: Summary Table

Feature Padding Packing

Memory Usage More (due to gaps) Less

Speed Faster access Slower access

Feature Padding Packing

Compiler Default behavior Requires pragma/directive

Use Case Performance optimized Memory-constrained systems

📦 Memory Allocation Examples

1. Structure Size Calculation

struct Example {
char a; // 1 byte
// 3 bytes padding
int b; // 4 bytes
char c; // 1 byte
// 3 bytes padding
};

Total size = 12 bytes (on 4-byte alignment)

2. Union Memory Calculation

union U {
int a; // 4 bytes
float b; // 4 bytes
char str[10]; // 10 bytes
};
int main() {
printf("Size of union: %lu\n", sizeof(union U)); //
Output: 10
return 0;
}

Memory is shared, so size = largest member → str[10]

3. Nested Structure Memory

struct Inner {
int x;
char y;
};

struct Outer {
char z;
struct Inner i;
};

int main() {
printf("Size: %lu\n", sizeof(struct Outer)); //
Padding depends on platform
return 0;
}
🔁 Struct Inside Union
union Mixed {
int i;
struct {
char c;
float f;
} s;
};

int main() {
union Mixed m;
m.s.c = 'X';
m.s.f = 1.5;
printf("Char: %c, Float: %.2f\n", m.s.c, m.s.f);
return 0;
}

Total union size = size of the largest member (struct inside here)

🔁 Union Inside Struct

struct Holder {
char type;
union {
int i;
float f;
} value;
};

int main() {
struct Holder h;
h.type = 'i';
h.value.i = 100;
printf("Value: %d\n", h.value.i);
return 0;
}

💡 Practical Use Cases

Concept Use Case Example

Struct Grouping fields like name, age, marks

Union Same memory space used for different purposes

Enum Readable constant sets like Days, Levels

📚 BONUS: Full Example With Everything Combined

#include <stdio.h>
#include <string.h>
#pragma pack(1)

enum Gender {MALE, FEMALE, OTHER};

struct Date {
int day, month, year;
};

union ID {
int aadhaar;
char passport[10];
};

struct Person {
char name[50];
enum Gender gender;
struct Date dob;
union ID id;
};

int main() {
struct Person p;
strcpy(p.name, "Alice");
p.gender = FEMALE;
p.dob.day = 5;
p.dob.month = 3;
p.dob.year = 2000;
p.id.aadhaar = 123456789;

printf("Name: %s\n", p.name);

printf("Gender: %d\n", p.gender); // 1 for FEMALE
printf("DOB: %02d-%02d-%04d\n", p.dob.day,
p.dob.month, p.dob.year);
printf("Aadhaar: %d\n", p.id.aadhaar);

printf("Total Size of Person: %lu bytes\n",

sizeof(struct Person));
return 0;
}