Function Assembly Patterns

int add_values(int a, int b) {
    return 0;
}

Assembly implementation follows stack-based parameter passing from right to left, with return values stored in EAX. EBP represents the stack base pointer, while ESP tracks the stack top.

Variable Types

Global Variables

• Memory address and size determined during compilation
• Variable names serve as memory address aliases
• Memory addresses remain constant unless recompiled
• Accessible and modifiable by any program component
• Used as base addresses in game hacking techniques

Local Variables

• Allocated within function scope
• Memory space exists only during function execution
• Stack-allocated memory with unpredictable addresses
• Limited to function internal usage due to address uncertainty

Signed vs Unsigned Number Representation

Signed and unsigned numbers share identical memory storage patterns but differ during extension and comparison operations:

• Char to int conversion: Signed numbers extend with sign bit replication, unsigned with zero padding
• Value comparison: Unsigned -1 (0xFF) exceeds unsigned 1 (0x01) due to 255 vs 1 interpretation
• Signed comparisons maintain expected mathematical relationships

Floating-Point Storage Format

Float and double types adhere to IEEE encoding standards rather than two's complement integer representation. Precision depends on mantissa bit count:

• Float: 23-bit mantissa provides 7 significant digits (2^23 = 8388608)
• Double: 53-bit mantissa supports approximately 16 significant digits

Chinese Character Encoding

Characters beyond ASCII 127 utilize multi-byte encoding schemes. GB2312 encoding represents Chinese characters using two consecutive bytes with values exceeding 127, replacing extended ASCII interpretations.

Switch Statement Efficiency

Switch statements employ jump table optimization rather than sequential comparison chains:

• Creates direct address mapping table
• Calculates jump offset via parameter minus first case address
• Handles non-continuous cases using default address substitution
• Eliminates repeated conditional checking

Structure Byte Alignment

Default Alignment

Structures align to the largest member's size. Mixed int (4 bytes) and char (1 byte) members result in 8-byte structures rather than 5 bytes.

Custom Alignment

#pragma pack(n) directive modifies alignment behavior. Final structure size becomes the smallest multiple of the pack value and largest member size. Use #pragma pack() to restore default behavior.

Pointer Arithmetic Operations

Pointer increment/decrement behavior depends on dereference level (excluding function pointers):

• Remove one asterisk and examine left side
• Remaining asterisks indicate 4-byte increments
• No asterisks result in 1-byte increments

Common Calling Conventions

Three primary calling conventions govern parameter passing and stack management.

Duplicate Inclusion Resolution

Conditional Compilation

#ifndef HEADER_NAME
#define HEADER_NAME
// Header content
#endif

Forward Declarations

Forward declarations provide type information without complete definitions, resolving circular dependencies between structures and functions during compilation.