Skip to content
LAM
Read Home Blog
Make Projects HTML Tools Games
Touch grass Notes Resume Links
Home Blog HTML Projects
Tools Games Notes Resume Links
Back C Composite Data Types | 8-Bit Programming Guide Programming
Download Open
Show description 2,049 chars · Programming

C Composite Data Types | 8-Bit Programming Guide

C Composite Data Types | 8-Bit Programming Guide








C COMPOSITE DATA

Master Structures, Enums & Typedefs









Introduction

Structures

Enumerations

Typedefs

Examples

Memory









Introduction to Composite Data Types


Welcome to the world of C composite data types! In this comprehensive guide, we'll explore three fundamental concepts that allow you to create more complex and organized data structures in C programming:



Structures (struct) - Group related variables together

Enumerations (enum) - Define named constants

Type Definitions (typedef) - Create aliases for existing types




Why Use Composite Data Types?
These constructs help you write more organized, readable, and maintainable code by grouping related data together and creating meaningful names for your data types.






Structures (struct)



What is a Structure?

A structure is a user-defined data type that groups together variables of different types under a single name. Think of it as a blueprint for creating related data.





Basic Syntax


struct StructureName {
datatype member1;
datatype member2;
// ... more members
};






Real Example: Course Structure


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

struct Course {
int sln;
char title[256];
char instructor[250];
int time;
};

void main() {
struct Course ser222;

ser222.sln = 1774;
strcpy(ser222.title, "Data Structures & Algorithms");
strcpy(ser222.instructor, "Acuna, Ruben");

printf("Memory allocated for this structure is %d", sizeof(ser222));
}






Interactive Structure Memory Layout

Click the button to see how memory is allocated for the Course structure:

Calculate Memory






Important Notes:
• Structure members are stored in contiguous memory
• The total size may be larger due to padding/alignment
• Use dot notation (.) to access members






Enumerations (enum)



What is an Enumeration?

An enumeration defines a type that consists of a set of named constants.…

C Composite Data Types | 8-Bit Programming Guide

38,032 bytes · HTML source
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>C Composite Data Types | 8-Bit Programming Guide</title>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&family=Fira+Code:wght@300;400;500;700&display=swap');
        
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        :root {
            --bg-primary: #0a0a0f;
            --bg-secondary: #1a1a2e;
            --bg-tertiary: #16213e;
            --accent-neon: #00ffff;
            --accent-pink: #ff00ff;
            --accent-green: #00ff00;
            --accent-yellow: #ffff00;
            --text-primary: #e0e0e0;
            --text-secondary: #b0b0b0;
            --text-dim: #808080;
            --border-color: #333366;
            --error-color: #ff4444;
            --success-color: #44ff44;
        }

        body {
            font-family: 'Orbitron', monospace;
            background: var(--bg-primary);
            color: var(--text-primary);
            line-height: 1.6;
            overflow-x: hidden;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 0 20px;
        }

        /* Header */
        .header {
            background: linear-gradient(45deg, var(--bg-secondary), var(--bg-tertiary));
            padding: 40px 0;
            border-bottom: 3px solid var(--accent-neon);
            box-shadow: 0 4px 20px rgba(0, 255, 255, 0.3);
            position: relative;
            overflow: hidden;
        }

        .header::before {
            content: '';
            position: absolute;
            top: 0;
            left: -100%;
            width: 100%;
            height: 100%;
            background: linear-gradient(90deg, transparent, rgba(0, 255, 255, 0.1), transparent);
            animation: scan 3s infinite;
        }

        @keyframes scan {
            0% { left: -100%; }
            100% { left: 100%; }
        }

        .header h1 {
            font-size: 3rem;
            font-weight: 900;
            text-align: center;
            color: var(--accent-neon);
            text-shadow: 0 0 20px var(--accent-neon);
            margin-bottom: 10px;
            letter-spacing: 3px;
        }

        .header .subtitle {
            text-align: center;
            font-size: 1.2rem;
            color: var(--text-secondary);
            font-weight: 400;
        }

        /* Navigation */
        .nav {
            background: var(--bg-secondary);
            padding: 15px 0;
            border-bottom: 2px solid var(--border-color);
            position: sticky;
            top: 0;
            z-index: 100;
        }

        .nav-list {
            display: flex;
            justify-content: center;
            list-style: none;
            gap: 30px;
            flex-wrap: wrap;
        }

        .nav-item a {
            color: var(--text-primary);
            text-decoration: none;
            padding: 10px 20px;
            border: 2px solid var(--border-color);
            background: var(--bg-tertiary);
            transition: all 0.3s ease;
            text-transform: uppercase;
            font-weight: 700;
            letter-spacing: 1px;
            font-size: 0.9rem;
        }

        .nav-item a:hover {
            border-color: var(--accent-neon);
            box-shadow: 0 0 15px var(--accent-neon);
            color: var(--accent-neon);
            transform: translateY(-2px);
        }

        /* Main content */
        .main {
            padding: 40px 0;
        }

        .section {
            margin-bottom: 60px;
            background: var(--bg-secondary);
            border: 2px solid var(--border-color);
            border-radius: 8px;
            padding: 40px;
            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
            position: relative;
        }

        .section::before {
            content: '';
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            height: 4px;
            background: linear-gradient(90deg, var(--accent-neon), var(--accent-pink), var(--accent-green), var(--accent-yellow));
            animation: rainbow 2s linear infinite;
        }

        @keyframes rainbow {
            0% { background-position: 0% 50%; }
            100% { background-position: 200% 50%; }
        }

        .section-title {
            font-size: 2.5rem;
            color: var(--accent-pink);
            text-shadow: 0 0 15px var(--accent-pink);
            margin-bottom: 30px;
            border-bottom: 2px solid var(--accent-pink);
            padding-bottom: 15px;
            font-weight: 700;
        }

        .subsection {
            margin: 30px 0;
        }

        .subsection-title {
            font-size: 1.5rem;
            color: var(--accent-green);
            margin-bottom: 15px;
            font-weight: 700;
        }

        /* Code blocks */
        .code-block {
            background: #000;
            border: 2px solid var(--accent-green);
            border-radius: 8px;
            padding: 25px;
            margin: 20px 0;
            font-family: 'Fira Code', monospace;
            position: relative;
            overflow-x: auto;
        }

        .code-block::before {
            content: 'CODE';
            position: absolute;
            top: -12px;
            left: 15px;
            background: var(--accent-green);
            color: #000;
            padding: 4px 12px;
            font-size: 0.8rem;
            font-weight: 700;
        }

        .code-block pre {
            color: var(--text-primary);
            font-size: 0.95rem;
            line-height: 1.4;
            margin: 0;
        }

        /* Syntax highlighting */
        .keyword { color: var(--accent-pink); font-weight: 700; }
        .string { color: var(--accent-yellow); }
        .comment { color: var(--text-dim); font-style: italic; }
        .number { color: var(--accent-neon); }
        .type { color: var(--accent-green); }

        /* Interactive elements */
        .interactive-demo {
            background: var(--bg-tertiary);
            border: 2px solid var(--accent-yellow);
            border-radius: 8px;
            padding: 25px;
            margin: 20px 0;
        }

        .demo-title {
            color: var(--accent-yellow);
            font-size: 1.2rem;
            margin-bottom: 15px;
            font-weight: 700;
        }

        .memory-visualization {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
            gap: 10px;
            margin: 20px 0;
        }

        .memory-block {
            background: var(--bg-primary);
            border: 2px solid var(--accent-neon);
            padding: 15px;
            text-align: center;
            font-family: 'Fira Code', monospace;
            transition: all 0.3s ease;
        }

        .memory-block:hover {
            box-shadow: 0 0 15px var(--accent-neon);
            transform: scale(1.05);
        }

        .memory-label {
            color: var(--accent-yellow);
            font-size: 0.8rem;
            margin-bottom: 5px;
        }

        .memory-value {
            color: var(--text-primary);
            font-weight: 700;
        }

        /* Buttons */
        .btn {
            background: var(--bg-tertiary);
            border: 2px solid var(--accent-neon);
            color: var(--accent-neon);
            padding: 12px 24px;
            font-family: 'Orbitron', monospace;
            font-weight: 700;
            cursor: pointer;
            transition: all 0.3s ease;
            text-transform: uppercase;
            letter-spacing: 1px;
        }

        .btn:hover {
            background: var(--accent-neon);
            color: #000;
            box-shadow: 0 0 20px var(--accent-neon);
            transform: translateY(-2px);
        }

        /* Info boxes */
        .info-box {
            background: linear-gradient(45deg, rgba(0, 255, 255, 0.1), rgba(255, 0, 255, 0.1));
            border-left: 4px solid var(--accent-neon);
            padding: 20px;
            margin: 20px 0;
            border-radius: 0 8px 8px 0;
        }

        .warning-box {
            background: linear-gradient(45deg, rgba(255, 255, 0, 0.1), rgba(255, 68, 68, 0.1));
            border-left: 4px solid var(--accent-yellow);
            padding: 20px;
            margin: 20px 0;
            border-radius: 0 8px 8px 0;
        }

        /* Footer */
        .footer {
            background: var(--bg-secondary);
            border-top: 3px solid var(--accent-pink);
            padding: 40px 0;
            text-align: center;
            margin-top: 60px;
        }

        /* Responsive */
        @media (max-width: 768px) {
            .header h1 {
                font-size: 2rem;
            }
            
            .nav-list {
                gap: 15px;
            }
            
            .nav-item a {
                padding: 8px 16px;
                font-size: 0.8rem;
            }
            
            .section {
                padding: 20px;
            }
            
            .section-title {
                font-size: 2rem;
            }
        }

        /* Scrollbar styling */
        ::-webkit-scrollbar {
            width: 12px;
        }

        ::-webkit-scrollbar-track {
            background: var(--bg-primary);
        }

        ::-webkit-scrollbar-thumb {
            background: var(--accent-neon);
            border-radius: 6px;
        }

        ::-webkit-scrollbar-thumb:hover {
            background: var(--accent-pink);
        }

        /* Animations */
        @keyframes glow {
            0%, 100% { text-shadow: 0 0 5px currentColor; }
            50% { text-shadow: 0 0 20px currentColor; }
        }

        .glow {
            animation: glow 2s ease-in-out infinite;
        }

        /* Progress indicator */
        .progress-bar {
            position: fixed;
            top: 0;
            left: 0;
            height: 4px;
            background: var(--accent-neon);
            transition: width 0.3s ease;
            z-index: 1000;
        }
    </style>
</head>
<body>
    <div class="progress-bar" id="progress"></div>

    <header class="header">
        <div class="container">
            <h1 class="glow">C COMPOSITE DATA</h1>
            <p class="subtitle">Master Structures, Enums & Typedefs</p>
        </div>
    </header>

    <nav class="nav">
        <div class="container">
            <ul class="nav-list">
                <li class="nav-item"><a href="#intro">Introduction</a></li>
                <li class="nav-item"><a href="#structures">Structures</a></li>
                <li class="nav-item"><a href="#enums">Enumerations</a></li>
                <li class="nav-item"><a href="#typedefs">Typedefs</a></li>
                <li class="nav-item"><a href="#examples">Examples</a></li>
                <li class="nav-item"><a href="#memory">Memory</a></li>
            </ul>
        </div>
    </nav>

    <main class="main">
        <div class="container">
            <section id="intro" class="section">
                <h2 class="section-title">Introduction to Composite Data Types</h2>
                
                <p>Welcome to the world of C composite data types! In this comprehensive guide, we'll explore three fundamental concepts that allow you to create more complex and organized data structures in C programming:</p>
                
                <ul style="margin: 20px 0 20px 40px; color: var(--text-secondary);">
                    <li><strong style="color: var(--accent-pink);">Structures (struct)</strong> - Group related variables together</li>
                    <li><strong style="color: var(--accent-green);">Enumerations (enum)</strong> - Define named constants</li>
                    <li><strong style="color: var(--accent-yellow);">Type Definitions (typedef)</strong> - Create aliases for existing types</li>
                </ul>

                <div class="info-box">
                    <strong>Why Use Composite Data Types?</strong><br>
                    These constructs help you write more organized, readable, and maintainable code by grouping related data together and creating meaningful names for your data types.
                </div>
            </section>

            <section id="structures" class="section">
                <h2 class="section-title">Structures (struct)</h2>
                
                <div class="subsection">
                    <h3 class="subsection-title">What is a Structure?</h3>
                    <p>A structure is a user-defined data type that groups together variables of different types under a single name. Think of it as a blueprint for creating related data.</p>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Basic Syntax</h3>
                    <div class="code-block">
                        <pre><span class="keyword">struct</span> <span class="type">StructureName</span> {
    <span class="type">datatype</span> member1;
    <span class="type">datatype</span> member2;
    <span class="comment">// ... more members</span>
};</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Real Example: Course Structure</h3>
                    <div class="code-block">
                        <pre><span class="keyword">#include</span> <span class="string">&lt;stdio.h&gt;</span>
<span class="keyword">#include</span> <span class="string">&lt;string.h&gt;</span>

<span class="keyword">struct</span> <span class="type">Course</span> {
    <span class="type">int</span> sln;
    <span class="type">char</span> title[<span class="number">256</span>];
    <span class="type">char</span> instructor[<span class="number">250</span>];
    <span class="type">int</span> time;
};

<span class="type">void</span> <span class="keyword">main</span>() {
    <span class="keyword">struct</span> <span class="type">Course</span> ser222;
    
    ser222.sln = <span class="number">1774</span>;
    <span class="keyword">strcpy</span>(ser222.title, <span class="string">"Data Structures & Algorithms"</span>);
    <span class="keyword">strcpy</span>(ser222.instructor, <span class="string">"Acuna, Ruben"</span>);
    
    <span class="keyword">printf</span>(<span class="string">"Memory allocated for this structure is %d"</span>, <span class="keyword">sizeof</span>(ser222));
}</pre>
                    </div>
                </div>

                <div class="interactive-demo">
                    <div class="demo-title">Interactive Structure Memory Layout</div>
                    <p>Click the button to see how memory is allocated for the Course structure:</p>
                    <button class="btn" onclick="showStructureMemory()">Calculate Memory</button>
                    <div id="structure-memory" class="memory-visualization"></div>
                </div>

                <div class="warning-box">
                    <strong>Important Notes:</strong><br>
                    • Structure members are stored in contiguous memory<br>
                    • The total size may be larger due to padding/alignment<br>
                    • Use dot notation (.) to access members
                </div>
            </section>

            <section id="enums" class="section">
                <h2 class="section-title">Enumerations (enum)</h2>
                
                <div class="subsection">
                    <h3 class="subsection-title">What is an Enumeration?</h3>
                    <p>An enumeration defines a type that consists of a set of named constants. Each enum value is internally represented as an integer, making them efficient while providing meaningful names.</p>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Basic Syntax</h3>
                    <div class="code-block">
                        <pre><span class="keyword">enum</span> { <span class="type">value1</span>, <span class="type">value2</span>, <span class="type">value3</span> } <span class="type">EnumName</span>;</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Example 1: Boolean Enumeration</h3>
                    <div class="code-block">
                        <pre><span class="comment">// Example 1:</span>
<span class="keyword">enum</span> { <span class="type">false</span>, <span class="type">true</span> } <span class="type">boolean</span>;

<span class="type">void</span> <span class="keyword">main</span>() {
    <span class="keyword">enum</span> <span class="type">boolean</span> x = <span class="type">false</span>;
    <span class="type">int</span> counter = <span class="number">5</span>;
    
    <span class="keyword">if</span> (x == <span class="type">true</span>) counter++;
}</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Example 2: Days of Week</h3>
                    <div class="code-block">
                        <pre><span class="comment">// Example 2:</span>
<span class="keyword">enum</span> {
    Sun=<span class="number">0</span>, Mon, Tue, Wed, Thu, Fri, Sat
} <span class="type">days</span>;

<span class="keyword">enum</span> <span class="type">days</span> day = Mon;</pre>
                    </div>
                </div>

                <div class="interactive-demo">
                    <div class="demo-title">Enum Value Explorer</div>
                    <p>See how enum values are automatically numbered:</p>
                    <button class="btn" onclick="showEnumValues()">Show Enum Values</button>
                    <div id="enum-values" class="memory-visualization"></div>
                </div>

                <div class="info-box">
                    <strong>Key Points:</strong><br>
                    • Enum values start at 0 by default<br>
                    • You can explicitly assign values<br>
                    • Each value is just an integer internally<br>
                    • Not type-safe in C (unlike C++)
                </div>
            </section>

            <section id="typedefs" class="section">
                <h2 class="section-title">Type Definitions (typedef)</h2>
                
                <div class="subsection">
                    <h3 class="subsection-title">What is typedef?</h3>
                    <p>The <code style="color: var(--accent-pink);">typedef</code> keyword creates an alias (synonym) for an existing data type. This makes your code more readable and easier to maintain.</p>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Basic Syntax</h3>
                    <div class="code-block">
                        <pre><span class="keyword">typedef</span> <span class="type">existing_type</span> <span class="type">new_name</span>;</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Example 1: Simple Type Alias</h3>
                    <div class="code-block">
                        <pre><span class="comment">// example 1</span>
<span class="keyword">typedef</span> <span class="type">int</span> <span class="type">boolean</span>;

<span class="type">void</span> <span class="keyword">main</span>() {
    <span class="type">boolean</span> x = <span class="number">0</span>;
    <span class="type">int</span> counter = <span class="number">5</span>;
    
    <span class="keyword">if</span> (x == <span class="number">0</span>) counter++;
}</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Example 2: Better Alternative</h3>
                    <div class="code-block">
                        <pre><span class="comment">// example 2</span>
<span class="keyword">typedef</span> <span class="type">char</span> <span class="type">FlagType</span>;

<span class="type">int</span> <span class="keyword">main</span>() {
    <span class="type">FlagType</span> x = <span class="string">'\0'</span>;
}</pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Typedef with Structures</h3>
                    <div class="code-block">
                        <pre><span class="comment">// Combining typedef with struct</span>
<span class="keyword">typedef</span> <span class="keyword">struct</span> {
    <span class="type">int</span> x, y;
    <span class="type">char</span> symbol;
} <span class="type">Point</span>;

<span class="comment">// Now you can use Point directly</span>
<span class="type">Point</span> player = {<span class="number">10</span>, <span class="number">20</span>, <span class="string">'@'</span>};</pre>
                    </div>
                </div>

                <div class="info-box">
                    <strong>Why use char instead of int for boolean?</strong><br>
                    Using <code>char</code> (1 byte) instead of <code>int</code> (typically 4 bytes) saves memory when you only need to represent simple true/false or flag values.
                </div>
            </section>

            <section id="examples" class="section">
                <h2 class="section-title">Practical Examples</h2>
                
                <div class="subsection">
                    <h3 class="subsection-title">Game Character System</h3>
                    <div class="code-block">
                        <pre><span class="keyword">#include</span> <span class="string">&lt;stdio.h&gt;</span>
<span class="keyword">#include</span> <span class="string">&lt;string.h&gt;</span>

<span class="comment">// Enum for character classes</span>
<span class="keyword">typedef</span> <span class="keyword">enum</span> {
    WARRIOR, MAGE, ARCHER, ROGUE
} <span class="type">CharacterClass</span>;

<span class="comment">// Enum for game states</span>
<span class="keyword">typedef</span> <span class="keyword">enum</span> {
    MENU, PLAYING, PAUSED, GAME_OVER
} <span class="type">GameState</span>;

<span class="comment">// Structure for game character</span>
<span class="keyword">typedef</span> <span class="keyword">struct</span> {
    <span class="type">char</span> name[<span class="number">50</span>];
    <span class="type">CharacterClass</span> class;
    <span class="type">int</span> health;
    <span class="type">int</span> mana;
    <span class="type">int</span> level;
    <span class="type">float</span> experience;
} <span class="type">Character</span>;

<span class="type">void</span> <span class="keyword">displayCharacter</span>(<span class="type">Character</span> *c) {
    <span class="type">char</span> *classes[] = {<span class="string">"Warrior"</span>, <span class="string">"Mage"</span>, <span class="string">"Archer"</span>, <span class="string">"Rogue"</span>};
    
    <span class="keyword">printf</span>(<span class="string">"=== Character Info ===\n"</span>);
    <span class="keyword">printf</span>(<span class="string">"Name: %s\n"</span>, c-&gt;name);
    <span class="keyword">printf</span>(<span class="string">"Class: %s\n"</span>, classes[c-&gt;class]);
    <span class="keyword">printf</span>(<span class="string">"Level: %d\n"</span>, c-&gt;level);
    <span class="keyword">printf</span>(<span class="string">"Health: %d\n"</span>, c-&gt;health);
    <span class="keyword">printf</span>(<span class="string">"Mana: %d\n"</span>, c-&gt;mana);
}

<span class="type">int</span> <span class="keyword">main</span>() {
    <span class="type">Character</span> player;
    <span class="type">GameState</span> currentState = PLAYING;
    
    <span class="comment">// Initialize character</span>
    <span class="keyword">strcpy</span>(player.name, <span class="string">"CodeWarrior"</span>);
    player.class = WARRIOR;
    player.health = <span class="number">100</span>;
    player.mana = <span class="number">50</span>;
    player.level = <span class="number">1</span>;
    player.experience = <span class="number">0.0</span>;
    
    <span class="keyword">displayCharacter</span>(&amp;player);
    
    <span class="keyword">printf</span>(<span class="string">"\nCharacter size: %zu bytes\n"</span>, <span class="keyword">sizeof</span>(player));
    
    <span class="keyword">return</span> <span class="number">0</span>;
}</pre>
                    </div>
                </div>

                <div class="interactive-demo">
                    <div class="demo-title">Character Creation Simulator</div>
                    <p>Create your own character and see the memory layout:</p>
                    <div style="margin: 15px 0;">
                        <label style="color: var(--accent-yellow);">Character Name:</label><br>
                        <input type="text" id="char-name" style="padding: 8px; margin: 5px 0; background: var(--bg-primary); color: var(--text-primary); border: 2px solid var(--border-color);" placeholder="Enter name">
                    </div>
                    <div style="margin: 15px 0;">
                        <label style="color: var(--accent-yellow);">Character Class:</label><br>
                        <select id="char-class" style="padding: 8px; margin: 5px 0; background: var(--bg-primary); color: var(--text-primary); border: 2px solid var(--border-color);">
                            <option value="0">Warrior</option>
                            <option value="1">Mage</option>
                            <option value="2">Archer</option>
                            <option value="3">Rogue</option>
                        </select>
                    </div>
                    <button class="btn" onclick="createCharacter()">Create Character</button>
                    <div id="character-display"></div>
                </div>
            </section>

            <section id="memory" class="section">
                <h2 class="section-title">Memory Management & Best Practices</h2>
                
                <div class="subsection">
                    <h3 class="subsection-title">Memory Layout of Structures</h3>
                    <p>Understanding how structures are laid out in memory is crucial for efficient programming:</p>
                    
                    <div class="code-block">
                        <pre><span class="keyword">struct</span> <span class="type">Example</span> {
    <span class="type">char</span> a;      <span class="comment">// 1 byte</span>
    <span class="type">int</span> b;       <span class="comment">// 4 bytes (typically)</span>
    <span class="type">char</span> c;      <span class="comment">// 1 byte</span>
    <span class="type">double</span> d;    <span class="comment">// 8 bytes</span>
};

<span class="comment">// Actual memory layout with padding:</span>
<span class="comment">// [a][pad][pad][pad][b][b][b][b][c][pad][pad][pad][pad][pad][pad][pad][d][d][d][d][d][d][d][d]</span></pre>
                    </div>
                </div>

                <div class="subsection">
                    <h3 class="subsection-title">Best Practices</h3>
                    <ul style="margin-left: 40px; color: var(--text-secondary);">
                        <li><strong style="color: var(--accent-neon);">Use meaningful names:</strong> Make your code self-documenting</li>
                        <li><strong style="color: var(--accent-neon);">Order members by size:</strong> Place larger types first to minimize padding</li>
                        <li><strong style="color: var(--accent-neon);">Use typedef consistently:</strong> Create aliases for complex types</li>
                        <li><strong style="color: var(--accent-neon);">Initialize structures:</strong> Always initialize your structures to avoid garbage values</li>
                        <li><strong style="color: var(--accent-neon);">Use enums for constants:</strong> Replace magic numbers with meaningful enum values</li>
                    </ul>
                </div>

                <div class="warning-box">
                    <strong>Common Pitfalls to Avoid:</strong><br>
                    • Don't assume enum values without checking<br>
                    • Remember that enums are just integers in C<br>
                    • Be aware of structure padding<br>
                    • Always check array bounds in structures
                </div>

                <div class="interactive-demo">
                    <div class="demo-title">Memory Size Calculator</div>
                    <p>Compare different structure layouts and their memory usage:</p>
                    <button class="btn" onclick="compareMemoryLayouts()">Compare Layouts</button>
                    <div id="memory-comparison"></div>
                </div>
            </section>
        </div>
    </main>

    <footer class="footer">
        <div class="container">
            <p>&copy; 2025 C Programming Guide | Master the fundamentals, build the future</p>
            <p style="margin-top: 10px; color: var(--text-dim);">Keep coding, keep learning! 🚀</p>
        </div>
    </footer>

    <script>
        // Progress bar functionality
        window.addEventListener('scroll', () => {
            const winScroll = document.body.scrollTop || document.documentElement.scrollTop;
            const height = document.documentElement.scrollHeight - document.documentElement.clientHeight;
            const scrolled = (winScroll / height) * 100;
            document.getElementById('progress').style.width = scrolled + '%';
        });

        // Smooth scrolling for navigation
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });

        // Interactive demonstrations
        function showStructureMemory() {
            const container = document.getElementById('structure-memory');
            const structureSize = {
                sln: 4,
                title: 256,
                instructor: 250,
                time: 4
            };
            
            let html = '<h4 style="color: var(--accent-yellow); margin-bottom: 15px;">Course Structure Memory Layout:</h4>';
            
            Object.entries(structureSize).forEach(([member, size]) => {
                html += `
                    <div class="memory-block">
                        <div class="memory-label">${member}</div>
                        <div class="memory-value">${size} bytes</div>
                    </div>
                `;
            });
            
            const totalSize = Object.values(structureSize).reduce((sum, size) => sum + size, 0);
            html += `<div style="margin-top: 20px; text-align: center; color: var(--accent-pink); font-weight: 700;">Total: ${totalSize} bytes</div>`;
            
            container.innerHTML = html;
        }

        function showEnumValues() {
            const container = document.getElementById('enum-values');
            const enumValues = [
                { name: 'false', value: 0 },
                { name: 'true', value: 1 },
                { name: 'Sun', value: 0 },
                { name: 'Mon', value: 1 },
                { name: 'Tue', value: 2 },
                { name: 'Wed', value: 3 },
                { name: 'Thu', value: 4 },
                { name: 'Fri', value: 5 },
                { name: 'Sat', value: 6 }
            ];
            
            let html = '<h4 style="color: var(--accent-yellow); margin-bottom: 15px;">Enum Values:</h4>';
            
            enumValues.forEach(({name, value}) => {
                html += `
                    <div class="memory-block">
                        <div class="memory-label">${name}</div>
                        <div class="memory-value">${value}</div>
                    </div>
                `;
            });
            
            container.innerHTML = html;
        }

        function createCharacter() {
            const name = document.getElementById('char-name').value || 'Anonymous';
            const classIndex = parseInt(document.getElementById('char-class').value);
            const classes = ['Warrior', 'Mage', 'Archer', 'Rogue'];
            const stats = [
                { health: 120, mana: 30 }, // Warrior
                { health: 80, mana: 150 },  // Mage
                { health: 100, mana: 70 },  // Archer
                { health: 90, mana: 60 }    // Rogue
            ];
            
            const container = document.getElementById('character-display');
            const characterStats = stats[classIndex];
            
            container.innerHTML = `
                <div style="margin-top: 20px; padding: 20px; background: var(--bg-primary); border: 2px solid var(--accent-green); border-radius: 8px;">
                    <h4 style="color: var(--accent-green); margin-bottom: 15px;">Character Created!</h4>
                    <p><strong>Name:</strong> ${name}</p>
                    <p><strong>Class:</strong> ${classes[classIndex]}</p>
                    <p><strong>Health:</strong> ${characterStats.health}</p>
                    <p><strong>Mana:</strong> ${characterStats.mana}</p>
                    <p><strong>Level:</strong> 1</p>
                    <div style="margin-top: 15px; color: var(--text-dim); font-size: 0.9rem;">
                        Memory usage: ~70 bytes (including padding)
                    </div>
                </div>
            `;
        }

        function compareMemoryLayouts() {
            const container = document.getElementById('memory-comparison');
            
            const layouts = [
                {
                    name: 'Poor Layout',
                    structure: 'char(1) + int(4) + char(1) + double(8)',
                    actualSize: 24,
                    explanation: 'Padding between members wastes space'
                },
                {
                    name: 'Good Layout', 
                    structure: 'double(8) + int(4) + char(1) + char(1)',
                    actualSize: 16,
                    explanation: 'Ordered by size, minimal padding'
                }
            ];
            
            let html = '<h4 style="color: var(--accent-yellow); margin-bottom: 15px;">Memory Layout Comparison:</h4>';
            
            layouts.forEach(layout => {
                html += `
                    <div style="background: var(--bg-primary); border: 2px solid var(--accent-neon); padding: 20px; margin: 10px 0; border-radius: 8px;">
                        <h5 style="color: var(--accent-neon); margin-bottom: 10px;">${layout.name}</h5>
                        <p><strong>Structure:</strong> ${layout.structure}</p>
                        <p><strong>Actual Size:</strong> ${layout.actualSize} bytes</p>
                        <p style="color: var(--text-dim); font-size: 0.9rem;">${layout.explanation}</p>
                    </div>
                `;
            });
            
            html += `<div style="text-align: center; margin-top: 20px; color: var(--accent-pink); font-weight: 700;">
                Space saved: ${layouts[0].actualSize - layouts[1].actualSize} bytes (${Math.round((1 - layouts[1].actualSize/layouts[0].actualSize) * 100)}% reduction!)
            </div>`;
            
            container.innerHTML = html;
        }

        // Add some dynamic visual effects
        document.addEventListener('DOMContentLoaded', function() {
            // Add typing animation to code blocks
            const codeBlocks = document.querySelectorAll('.code-block pre');
            codeBlocks.forEach((block, index) => {
                const observer = new IntersectionObserver((entries) => {
                    entries.forEach(entry => {
                        if (entry.isIntersecting) {
                            entry.target.style.opacity = '1';
                            entry.target.style.transform = 'translateY(0)';
                        }
                    });
                });
                
                block.style.opacity = '0';
                block.style.transform = 'translateY(20px)';
                block.style.transition = 'all 0.6s ease';
                block.style.transitionDelay = `${index * 0.1}s`;
                
                observer.observe(block);
            });
        });
    </script>
</body>
</html>