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 Programming: Data Types, Memory & Strings Programming
Download Open
Show description 2,401 chars · Programming

C Programming: Data Types, Memory & Strings

C Programming: Data Types, Memory & Strings




C Programming: Data Types, Memory & Strings




🔗 C and C++ Data Type Hierarchy



Data Type




Scalar

Function

void

Aggregate




Pointer

Arithmetic

Enumeration

Array

Structure

Variant




Floating-point

bool

Integer

enum

struct

union




float

double

char

short

int

long

signed

unsigned






Key Concepts:



Scalar Types: Single values (int, float, char, pointers)

Aggregate Types: Collections of data (arrays, structures, unions)

Function Types: Represent functions and their signatures

void Type: Represents absence of type or value

Type Qualifiers: const, volatile, restrict modify behavior









🏨 Memory Organization

Memory is byte-addressable - each byte has a unique address



Memory Layout Example:


0x1000
65 ('A')
char
1 byte



0x1001
66 ('B')
char
1 byte



0x1002
0x00
char
null terminator



0x1004
1234
int
4 bytes (typically)



0x1008
3.14159
float
4 bytes



0x100C
0x1000
char*
pointer to char (8 bytes on 64-bit)





Animate Data Flow


Memory Organization Test Points:


Each byte has a unique memory address

Addresses increase sequentially (0x1000, 0x1001, 0x1002...)

Different data types occupy different amounts of memory

Memory alignment affects where data is stored

Pointers store memory addresses as their values









📍 Byte Addressable Memory - Code Examples



// Basic pointer and address demonstration
#include <stdio.h>

int main() {
int n1 = 4, n2 = 8;
int *pt1 = &n1, *pt2 = &n2;
char c1 = 'A', c2 = 'B', c6;
char *pc1 = &c1, *pc2 = &c2, *pc3 = &c6;

// Print addresses and values
printf("c1 address = %p, c1 value = %c\n", pc1, *pc1);
printf("c2 address = %p, c2 value = %c\n", pc2, *pc2);
printf("n1 address = %p, n1 value = %d\n", pt1, *pt1);
printf("n2 address = %p, n2 value = %d\n", pt2, *pt2);

return 0;
}




// Pointer arithmetic and memory addresses
#include <stdio.h>

int main() {
int arr[] = {10, 20, 30, 40};
int *ptr = arr;

// Show how array elements are stored in consecutive memory
for(int i = 0; i < 4; i++) {
printf("arr[%d] = %d, address = %p\n",
i, *(ptr + i), (ptr + i));
}

// Show byte-level addressing
char *byte_ptr = (char*)ptr;
printf("\nByte-by-byte view of first integer:\n");
for(…

C Programming: Data Types, Memory & Strings

29,495 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 Programming: Data Types, Memory & Strings</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            background: linear-gradient(135deg, #1a1a1a 0%, #2d2d2d 100%);
            color: #e0e0e0;
            font-family: 'Courier New', monospace;
            line-height: 1.6;
            min-height: 100vh;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        
        h1 {
            text-align: center;
            color: #64b5f6;
            margin-bottom: 30px;
            text-shadow: 0 0 10px rgba(100, 181, 246, 0.3);
            font-size: 2.5em;
        }
        
        h2 {
            color: #81c784;
            margin: 30px 0 20px 0;
            border-bottom: 2px solid #404040;
            padding-bottom: 10px;
            font-size: 1.8em;
        }
        
        h3 {
            color: #ffb74d;
            margin: 20px 0 15px 0;
            font-size: 1.4em;
        }
        
        .section {
            background: rgba(45, 45, 45, 0.8);
            margin: 20px 0;
            padding: 25px;
            border-radius: 10px;
            border: 1px solid #404040;
            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.3);
        }
        
        .hierarchy-tree {
            text-align: center;
            margin: 20px 0;
            font-family: monospace;
            font-size: 14px;
        }
        
        .tree-level {
            margin: 15px 0;
            display: flex;
            justify-content: center;
            flex-wrap: wrap;
            gap: 20px;
        }
        
        .tree-node {
            background: linear-gradient(145deg, #404040, #505050);
            padding: 8px 15px;
            border-radius: 8px;
            border: 2px solid #64b5f6;
            color: #e0e0e0;
            min-width: 100px;
            text-align: center;
            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.4);
            transition: all 0.3s ease;
        }
        
        .tree-node:hover {
            transform: translateY(-2px);
            box-shadow: 0 4px 12px rgba(100, 181, 246, 0.3);
        }
        
        .primitive-type {
            background: linear-gradient(145deg, #2d4a2d, #3d5a3d);
            border-color: #81c784;
        }
        
        .code-block {
            background: #1e1e1e;
            border: 1px solid #404040;
            border-radius: 8px;
            padding: 20px;
            margin: 15px 0;
            overflow-x: auto;
            font-family: 'Courier New', monospace;
            font-size: 14px;
            line-height: 1.4;
        }
        
        .code-block pre {
            color: #e0e0e0;
            white-space: pre-wrap;
        }
        
        .keyword { color: #569cd6; font-weight: bold; }
        .string { color: #ce9178; }
        .number { color: #b5cea8; }
        .comment { color: #6a9955; font-style: italic; }
        .type { color: #4ec9b0; }
        
        .memory-visual {
            background: #2a2a2a;
            border: 2px solid #64b5f6;
            border-radius: 10px;
            padding: 20px;
            margin: 20px 0;
            position: relative;
            overflow: hidden;
        }
        
        .memory-address {
            display: flex;
            align-items: center;
            margin: 5px 0;
            padding: 8px;
            background: rgba(100, 181, 246, 0.1);
            border-radius: 5px;
            transition: all 0.3s ease;
        }
        
        .memory-address:hover {
            background: rgba(100, 181, 246, 0.2);
            transform: scale(1.02);
        }
        
        .address {
            width: 120px;
            color: #ffb74d;
            font-weight: bold;
        }
        
        .value {
            width: 100px;
            color: #81c784;
            text-align: center;
        }
        
        .data-type {
            width: 80px;
            color: #f48fb1;
            text-align: center;
        }
        
        .description {
            color: #e0e0e0;
            margin-left: 20px;
        }
        
        .animate-data {
            animation: dataFlow 2s ease-in-out infinite;
        }
        
        @keyframes dataFlow {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; transform: translateX(5px); }
        }
        
        .string-demo {
            background: #2a2a2a;
            border: 2px solid #81c784;
            border-radius: 10px;
            padding: 20px;
            margin: 20px 0;
        }
        
        .string-chars {
            display: flex;
            flex-wrap: wrap;
            gap: 5px;
            margin: 10px 0;
        }
        
        .char-box {
            width: 40px;
            height: 40px;
            background: rgba(129, 199, 132, 0.2);
            border: 1px solid #81c784;
            border-radius: 5px;
            display: flex;
            align-items: center;
            justify-content: center;
            font-weight: bold;
            color: #81c784;
        }
        
        .null-terminator {
            background: rgba(244, 143, 177, 0.2);
            border-color: #f48fb1;
            color: #f48fb1;
        }
        
        .test-points {
            background: rgba(255, 183, 77, 0.1);
            border: 1px solid #ffb74d;
            border-radius: 8px;
            padding: 15px;
            margin: 15px 0;
        }
        
        .test-points ul {
            margin-left: 20px;
        }
        
        .test-points li {
            margin: 5px 0;
            color: #e0e0e0;
        }
        
        .highlight {
            background: rgba(100, 181, 246, 0.2);
            padding: 2px 4px;
            border-radius: 3px;
        }
        
        .interactive-btn {
            background: linear-gradient(145deg, #404040, #505050);
            color: #64b5f6;
            border: 2px solid #64b5f6;
            padding: 10px 20px;
            border-radius: 8px;
            cursor: pointer;
            margin: 10px 5px;
            font-family: 'Courier New', monospace;
            transition: all 0.3s ease;
        }
        
        .interactive-btn:hover {
            background: rgba(100, 181, 246, 0.1);
            transform: translateY(-2px);
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>C Programming: Data Types, Memory & Strings</h1>
        
        <!-- Data Type Hierarchy Section -->
        <div class="section">
            <h2>🔗 C and C++ Data Type Hierarchy</h2>
            <div class="hierarchy-tree">
                <div class="tree-level">
                    <div class="tree-node">Data Type</div>
                </div>
                <div class="tree-level">
                    <div class="tree-node">Scalar</div>
                    <div class="tree-node">Function</div>
                    <div class="tree-node">void</div>
                    <div class="tree-node">Aggregate</div>
                </div>
                <div class="tree-level">
                    <div class="tree-node">Pointer</div>
                    <div class="tree-node">Arithmetic</div>
                    <div class="tree-node">Enumeration</div>
                    <div class="tree-node">Array</div>
                    <div class="tree-node">Structure</div>
                    <div class="tree-node">Variant</div>
                </div>
                <div class="tree-level">
                    <div class="tree-node">Floating-point</div>
                    <div class="tree-node">bool</div>
                    <div class="tree-node">Integer</div>
                    <div class="tree-node">enum</div>
                    <div class="tree-node">struct</div>
                    <div class="tree-node">union</div>
                </div>
                <div class="tree-level">
                    <div class="tree-node primitive-type">float</div>
                    <div class="tree-node primitive-type">double</div>
                    <div class="tree-node primitive-type">char</div>
                    <div class="tree-node primitive-type">short</div>
                    <div class="tree-node primitive-type">int</div>
                    <div class="tree-node primitive-type">long</div>
                    <div class="tree-node primitive-type">signed</div>
                    <div class="tree-node primitive-type">unsigned</div>
                </div>
            </div>
            
            <h3>Key Concepts:</h3>
            <div class="test-points">
                <ul>
                    <li><strong>Scalar Types:</strong> Single values (int, float, char, pointers)</li>
                    <li><strong>Aggregate Types:</strong> Collections of data (arrays, structures, unions)</li>
                    <li><strong>Function Types:</strong> Represent functions and their signatures</li>
                    <li><strong>void Type:</strong> Represents absence of type or value</li>
                    <li><strong>Type Qualifiers:</strong> const, volatile, restrict modify behavior</li>
                </ul>
            </div>
        </div>
        
        <!-- Memory Organization Section -->
        <div class="section">
            <h2>🏨 Memory Organization</h2>
            <p>Memory is <span class="highlight">byte-addressable</span> - each byte has a unique address</p>
            
            <div class="memory-visual" id="memoryDemo">
                <h3>Memory Layout Example:</h3>
                <div class="memory-address">
                    <span class="address">0x1000</span>
                    <span class="value">65 ('A')</span>
                    <span class="data-type">char</span>
                    <span class="description">1 byte</span>
                </div>
                <div class="memory-address">
                    <span class="address">0x1001</span>
                    <span class="value">66 ('B')</span>
                    <span class="data-type">char</span>
                    <span class="description">1 byte</span>
                </div>
                <div class="memory-address">
                    <span class="address">0x1002</span>
                    <span class="value">0x00</span>
                    <span class="data-type">char</span>
                    <span class="description">null terminator</span>
                </div>
                <div class="memory-address">
                    <span class="address">0x1004</span>
                    <span class="value">1234</span>
                    <span class="data-type">int</span>
                    <span class="description">4 bytes (typically)</span>
                </div>
                <div class="memory-address">
                    <span class="address">0x1008</span>
                    <span class="value">3.14159</span>
                    <span class="data-type">float</span>
                    <span class="description">4 bytes</span>
                </div>
                <div class="memory-address">
                    <span class="address">0x100C</span>
                    <span class="value">0x1000</span>
                    <span class="data-type">char*</span>
                    <span class="description">pointer to char (8 bytes on 64-bit)</span>
                </div>
            </div>
            
            <button class="interactive-btn" onclick="animateMemory()">Animate Data Flow</button>
            
            <div class="test-points">
                <h3>Memory Organization Test Points:</h3>
                <ul>
                    <li>Each byte has a unique memory address</li>
                    <li>Addresses increase sequentially (0x1000, 0x1001, 0x1002...)</li>
                    <li>Different data types occupy different amounts of memory</li>
                    <li>Memory alignment affects where data is stored</li>
                    <li>Pointers store memory addresses as their values</li>
                </ul>
            </div>
        </div>
        
        <!-- Byte Addressable Memory Code Examples -->
        <div class="section">
            <h2>📍 Byte Addressable Memory - Code Examples</h2>
            
            <div class="code-block">
                <pre><span class="comment">// Basic pointer and address demonstration</span>
<span class="type">#include</span> <span class="string">&lt;stdio.h&gt;</span>

<span class="keyword">int</span> <span class="keyword">main</span>() {
    <span class="type">int</span> <span class="keyword">n1</span> = <span class="number">4</span>, <span class="keyword">n2</span> = <span class="number">8</span>;
    <span class="type">int</span> <span class="keyword">*pt1</span> = &<span class="keyword">n1</span>, <span class="keyword">*pt2</span> = &<span class="keyword">n2</span>;
    <span class="type">char</span> <span class="keyword">c1</span> = <span class="string">'A'</span>, <span class="keyword">c2</span> = <span class="string">'B'</span>, <span class="keyword">c6</span>;
    <span class="type">char</span> <span class="keyword">*pc1</span> = &<span class="keyword">c1</span>, <span class="keyword">*pc2</span> = &<span class="keyword">c2</span>, <span class="keyword">*pc3</span> = &<span class="keyword">c6</span>;
    
    <span class="comment">// Print addresses and values</span>
    <span class="keyword">printf</span>(<span class="string">"c1 address = %p, c1 value = %c\n"</span>, <span class="keyword">pc1</span>, <span class="keyword">*pc1</span>);
    <span class="keyword">printf</span>(<span class="string">"c2 address = %p, c2 value = %c\n"</span>, <span class="keyword">pc2</span>, <span class="keyword">*pc2</span>);
    <span class="keyword">printf</span>(<span class="string">"n1 address = %p, n1 value = %d\n"</span>, <span class="keyword">pt1</span>, <span class="keyword">*pt1</span>);
    <span class="keyword">printf</span>(<span class="string">"n2 address = %p, n2 value = %d\n"</span>, <span class="keyword">pt2</span>, <span class="keyword">*pt2</span>);
    
    <span class="keyword">return</span> <span class="number">0</span>;
}</pre>
            </div>
            
            <div class="code-block">
                <pre><span class="comment">// Pointer arithmetic and memory addresses</span>
<span class="type">#include</span> <span class="string">&lt;stdio.h&gt;</span>

<span class="keyword">int</span> <span class="keyword">main</span>() {
    <span class="type">int</span> <span class="keyword">arr</span>[] = {<span class="number">10</span>, <span class="number">20</span>, <span class="number">30</span>, <span class="number">40</span>};
    <span class="type">int</span> <span class="keyword">*ptr</span> = <span class="keyword">arr</span>;
    
    <span class="comment">// Show how array elements are stored in consecutive memory</span>
    <span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">i</span> &lt; <span class="number">4</span>; <span class="keyword">i</span>++) {
        <span class="keyword">printf</span>(<span class="string">"arr[%d] = %d, address = %p\n"</span>, 
               <span class="keyword">i</span>, <span class="keyword">*(ptr + i)</span>, (<span class="keyword">ptr + i</span>));
    }
    
    <span class="comment">// Show byte-level addressing</span>
    <span class="type">char</span> <span class="keyword">*byte_ptr</span> = (<span class="type">char</span>*)<span class="keyword">ptr</span>;
    <span class="keyword">printf</span>(<span class="string">"\nByte-by-byte view of first integer:\n"</span>);
    <span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">i</span> &lt; <span class="keyword">sizeof</span>(<span class="type">int</span>); <span class="keyword">i</span>++) {
        <span class="keyword">printf</span>(<span class="string">"Byte %d: %02X (address %p)\n"</span>, 
               <span class="keyword">i</span>, <span class="keyword">*(byte_ptr + i)</span>, (<span class="keyword">byte_ptr + i</span>));
    }
    
    <span class="keyword">return</span> <span class="number">0</span>;
}</pre>
            </div>
        </div>
        
        <!-- C Strings Section -->
        <div class="section">
            <h2>📝 C-Style Strings</h2>
            
            <div class="string-demo" id="stringDemo">
                <h3>String "Hello" in Memory:</h3>
                <div class="string-chars">
                    <div class="char-box">H</div>
                    <div class="char-box">e</div>
                    <div class="char-box">l</div>
                    <div class="char-box">l</div>
                    <div class="char-box">o</div>
                    <div class="char-box null-terminator">\0</div>
                </div>
                <p>Address: 0x2000  0x2001  0x2002  0x2003  0x2004  0x2005</p>
            </div>
            
            <div class="code-block">
                <pre><span class="comment">// C-Style String Examples</span>
<span class="type">#include</span> <span class="string">&lt;stdio.h&gt;</span>
<span class="type">#include</span> <span class="string">&lt;string.h&gt;</span>

<span class="keyword">int</span> <span class="keyword">main</span>() {
    <span class="comment">// Different ways to declare strings</span>
    <span class="type">char</span> <span class="keyword">str1</span>[] = <span class="string">"Hello"</span>;           <span class="comment">// Array on stack</span>
    <span class="type">char</span> <span class="keyword">*str2</span> = <span class="string">"World"</span>;           <span class="comment">// Pointer to string literal</span>
    <span class="type">char</span> <span class="keyword">str3</span>[<span class="number">20</span>];                   <span class="comment">// Uninitialized array</span>
    <span class="type">char</span> <span class="keyword">str4</span>[<span class="number">10</span>] = {<span class="string">'T'</span>, <span class="string">'e'</span>, <span class="string">'s'</span>, <span class="string">'t'</span>, <span class="string">'\0'</span>}; <span class="comment">// Character array</span>
    
    <span class="comment">// Show string properties</span>
    <span class="keyword">printf</span>(<span class="string">"str1 = \"%s\", length = %zu\n"</span>, <span class="keyword">str1</span>, <span class="keyword">strlen</span>(<span class="keyword">str1</span>));
    <span class="keyword">printf</span>(<span class="string">"str2 = \"%s\", length = %zu\n"</span>, <span class="keyword">str2</span>, <span class="keyword">strlen</span>(<span class="keyword">str2</span>));
    <span class="keyword">printf</span>(<span class="string">"str4 = \"%s\", length = %zu\n"</span>, <span class="keyword">str4</span>, <span class="keyword">strlen</span>(<span class="keyword">str4</span>));
    
    <span class="comment">// String operations</span>
    <span class="keyword">strcpy</span>(<span class="keyword">str3</span>, <span class="string">"Copied"</span>);
    <span class="keyword">printf</span>(<span class="string">"After strcpy: str3 = \"%s\"\n"</span>, <span class="keyword">str3</span>);
    
    <span class="keyword">strcat</span>(<span class="keyword">str3</span>, <span class="string">" String"</span>);
    <span class="keyword">printf</span>(<span class="string">"After strcat: str3 = \"%s\"\n"</span>, <span class="keyword">str3</span>);
    
    <span class="comment">// Character-by-character access</span>
    <span class="keyword">printf</span>(<span class="string">"\nCharacter-by-character access of str1:\n"</span>);
    <span class="keyword">for</span>(<span class="type">int</span> <span class="keyword">i</span> = <span class="number">0</span>; <span class="keyword">str1</span>[<span class="keyword">i</span>] != <span class="string">'\0'</span>; <span class="keyword">i</span>++) {
        <span class="keyword">printf</span>(<span class="string">"str1[%d] = '%c' (ASCII %d) at address %p\n"</span>, 
               <span class="keyword">i</span>, <span class="keyword">str1</span>[<span class="keyword">i</span>], <span class="keyword">str1</span>[<span class="keyword">i</span>], &<span class="keyword">str1</span>[<span class="keyword">i</span>]);
    }
    
    <span class="keyword">return</span> <span class="number">0</span>;
}</pre>
            </div>
            
            <div class="code-block">
                <pre><span class="comment">// Advanced String Operations</span>
<span class="type">#include</span> <span class="string">&lt;stdio.h&gt;</span>
<span class="type">#include</span> <span class="string">&lt;string.h&gt;</span>
<span class="type">#include</span> <span class="string">&lt;stdlib.h&gt;</span>

<span class="comment">// Custom string length function</span>
<span class="type">int</span> <span class="keyword">my_strlen</span>(<span class="keyword">const</span> <span class="type">char</span> <span class="keyword">*str</span>) {
    <span class="type">int</span> <span class="keyword">count</span> = <span class="number">0</span>;
    <span class="keyword">while</span>(<span class="keyword">*str</span> != <span class="string">'\0'</span>) {
        <span class="keyword">count</span>++;
        <span class="keyword">str</span>++;
    }
    <span class="keyword">return</span> <span class="keyword">count</span>;
}

<span class="comment">// Custom string copy function</span>
<span class="type">char</span>* <span class="keyword">my_strcpy</span>(<span class="type">char</span> <span class="keyword">*dest</span>, <span class="keyword">const</span> <span class="type">char</span> <span class="keyword">*src</span>) {
    <span class="type">char</span> <span class="keyword">*original_dest</span> = <span class="keyword">dest</span>;
    <span class="keyword">while</span>(<span class="keyword">*src</span> != <span class="string">'\0'</span>) {
        <span class="keyword">*dest</span> = <span class="keyword">*src</span>;
        <span class="keyword">dest</span>++;
        <span class="keyword">src</span>++;
    }
    <span class="keyword">*dest</span> = <span class="string">'\0'</span>; <span class="comment">// Don't forget null terminator!</span>
    <span class="keyword">return</span> <span class="keyword">original_dest</span>;
}

<span class="keyword">int</span> <span class="keyword">main</span>() {
    <span class="type">char</span> <span class="keyword">source</span>[] = <span class="string">"Programming"</span>;
    <span class="type">char</span> <span class="keyword">destination</span>[<span class="number">20</span>];
    
    <span class="keyword">printf</span>(<span class="string">"Source length (custom): %d\n"</span>, <span class="keyword">my_strlen</span>(<span class="keyword">source</span>));
    <span class="keyword">printf</span>(<span class="string">"Source length (library): %zu\n"</span>, <span class="keyword">strlen</span>(<span class="keyword">source</span>));
    
    <span class="keyword">my_strcpy</span>(<span class="keyword">destination</span>, <span class="keyword">source</span>);
    <span class="keyword">printf</span>(<span class="string">"Copied string: %s\n"</span>, <span class="keyword">destination</span>);
    
    <span class="comment">// Dynamic string allocation</span>
    <span class="type">char</span> <span class="keyword">*dynamic_str</span> = <span class="keyword">malloc</span>(<span class="number">50</span> * <span class="keyword">sizeof</span>(<span class="type">char</span>));
    <span class="keyword">strcpy</span>(<span class="keyword">dynamic_str</span>, <span class="string">"Dynamic Memory"</span>);
    <span class="keyword">printf</span>(<span class="string">"Dynamic string: %s\n"</span>, <span class="keyword">dynamic_str</span>);
    <span class="keyword">free</span>(<span class="keyword">dynamic_str</span>); <span class="comment">// Don't forget to free!</span>
    
    <span class="keyword">return</span> <span class="number">0</span>;
}</pre>
            </div>
            
            <button class="interactive-btn" onclick="demonstrateString()">Demonstrate String Operations</button>
        </div>
        
        <!-- Test Points Section -->
        <div class="section">
            <h2>🎯 Key Test Points & Concepts</h2>
            
            <h3>Data Types & Hierarchy</h3>
            <div class="test-points">
                <ul>
                    <li>Know the difference between <span class="highlight">scalar</span> and <span class="highlight">aggregate</span> types</li>
                    <li>Understand <span class="highlight">type qualifiers</span>: const, volatile, restrict</li>
                    <li>Memory sizes: char (1), short (2), int (4), long (8), pointer (8 on 64-bit)</li>
                    <li>Signed vs unsigned integer ranges</li>
                    <li>Float vs double precision and storage</li>
                </ul>
            </div>
            
            <h3>Memory Organization</h3>
            <div class="test-points">
                <ul>
                    <li>Each byte has a unique memory address</li>
                    <li>Addresses are typically displayed in <span class="highlight">hexadecimal</span></li>
                    <li>Memory alignment affects performance and layout</li>
                    <li>Stack vs heap memory allocation</li>
                    <li>Pointer arithmetic: ptr + 1 moves by sizeof(type) bytes</li>
                </ul>
            </div>
            
            <h3>C Strings</h3>
            <div class="test-points">
                <ul>
                    <li>C strings are <span class="highlight">null-terminated</span> character arrays</li>
                    <li>String literals are stored in read-only memory</li>
                    <li>strlen() returns length WITHOUT the null terminator</li>
                    <li>Buffer overflows can occur without bounds checking</li>
                    <li>String functions: strcpy, strcat, strcmp, strlen, strstr</li>
                    <li>Always allocate space for the null terminator (\0)</li>
                </ul>
            </div>
            
            <h3>Pointers & Addresses</h3>
            <div class="test-points">
                <ul>
                    <li><span class="highlight">&variable</span> gives address of variable</li>
                    <li><span class="highlight">*pointer</span> dereferences pointer to get value</li>
                    <li>Pointer arithmetic follows data type size</li>
                    <li>Array name is pointer to first element</li>
                    <li>Pointer to pointer concepts (char **)</li>
                    <li>NULL pointer (0x0) represents invalid address</li>
                </ul>
            </div>
        </div>
    </div>
    
    <script>
        // Animation functions
        function animateMemory() {
            const memoryAddresses = document.querySelectorAll('.memory-address');
            memoryAddresses.forEach((addr, index) => {
                setTimeout(() => {
                    addr.classList.add('animate-data');
                    setTimeout(() => {
                        addr.classList.remove('animate-data');
                    }, 1000);
                }, index * 200);
            });
        }
        
        function demonstrateString() {
            const stringChars = document.querySelectorAll('.char-box');
            stringChars.forEach((char, index) => {
                setTimeout(() => {
                    char.style.transform = 'scale(1.2)';
                    char.style.backgroundColor = index < 5 ? 'rgba(129, 199, 132, 0.5)' : 'rgba(244, 143, 177, 0.5)';
                    setTimeout(() => {
                        char.style.transform = 'scale(1)';
                        char.style.backgroundColor = index < 5 ? 'rgba(129, 199, 132, 0.2)' : 'rgba(244, 143, 177, 0.2)';
                    }, 500);
                }, index * 200);
            });
        }
        
        // Auto-animate on page load
        window.addEventListener('load', () => {
            setTimeout(animateMemory, 1000);
        });
        
        // Interactive hover effects
        document.querySelectorAll('.tree-node').forEach(node => {
            node.addEventListener('click', () => {
                node.style.transform = 'scale(1.1)';
                setTimeout(() => {
                    node.style.transform = 'scale(1)';
                }, 200);
            });
        });
    </script>
</body>
</html>