编程语言简述

温宇飞
88 阅读26分钟

编程语言是人与计算机沟通的桥梁，不同的编程语言具有不同的特性和设计哲学。了解这些特性有助于我们举一反三，快速学习某些语言。本文将简述编程语言的各种重要特性。

语言生命周期

编程语言从源代码到可执行程序的转换过程称为语言生命周期。这个过程主要由编译器和解释器完成，它们将高级编程语言转换为计算机能够理解和执行的指令。

编译型语言直接编译为机器码，解释型语言通过解释器执行。

特性编译型语言解释型语言
执行方式直接执行机器码逐行解释执行
启动速度慢（需要编译）快（直接执行）
运行速度快相对较慢
错误检测编译时发现运行时发现
跨平台性需要重新编译天然跨平台
内存使用较少较多
开发调试需要重新编译即时执行
调试难度较难较易
典型语言C, C++, RustPython, JavaScript, Ruby

编译型示例：

// 需要编译为可执行文件
gcc program.c -o program
./program

解释型示例：

# 直接解释执行
python script.py

编译器 (Compiler)

编译器是将高级编程语言源代码一次性转换为目标代码（通常是机器码）的程序。

  • 一次性转换：将整个程序源代码转换为目标代码
  • 生成可执行文件：输出独立的可执行程序
  • 静态分析：在编译时进行类型检查和优化
  • 高效执行：编译后的程序直接运行，无需解释器

编译过程

  1. 源代码
int x = 10 + 5;
  1. 词法分析 (Lexical Analysis)
  2. 语法分析 (Syntax Analysis)
  3. 语义分析 (Semantic Analysis)
  • 类型检查
  • 作用域分析
  • 符号表构建
  • 语义错误检测
  1. 中间代码生成 (Intermediate Code Generation)
t1 = 10
t2 = 5
t3 = t1 + t2
x = t3
  1. 代码优化 (Code Optimization)
x = 15  // 常量折叠
  1. 目标代码生成 (Target Code Generation)
; x86 汇编代码示例
mov eax, 15
mov [x], eax

解释器 (Interpreter)

解释器是逐行或逐块执行源代码的程序，不生成独立的目标代码。

  • 逐行执行：一次处理一行或一个语句
  • 动态执行：运行时进行类型检查和优化
  • 即时执行：边解释边执行
  • 跨平台性：同一份源代码可在不同平台运行

解释过程

  1. 源代码
x = 10 + 5;
  1. 词法分析
  2. 语法分析
  3. 语义分析
  • 动态类型检查
  • 变量绑定
  • 运行时错误检测
  1. 执行
# 解释器执行步骤
1. 计算 10 + 5 = 15
2. 将结果 15 赋值给变量 x
3. 在符号表中记录 x = 15

混合方式

编译型和解释型各有利弊，现代编程语言通常采用混合方式，结合编译和解释的优势。

  • 字节码: 先生成字节码，再解释执行
    • Java: .class 文件
    • Python: .pyc 文件
  • 即时编译 (JIT): 在运行时将热点代码编译为机器码
    • 流程: 解释执行 -> 热点代码识别 -> 即时编译为机器码 -> 优化编译
    • 主流解释器: V8 解释器(js) PyPy 解释器(python)

变量

变量是编程语言中存储数据的基本单位，可以理解为计算机内存中的一块存储空间，用于保存程序运行过程中的数据。

变量的生命周期

  1. 声明 (Declaration)：告诉编译器或解释器变量的存在和类型
  2. 定义 (Definition)：为变量分配内存空间
  3. 初始化 (Initialization)：给变量赋予初始值
  4. 更新 (Update)：改变变量的值
  5. 销毁 (Destruction)：释放变量占用的内存空间
  6. 作用域 (Scope)：变量在程序中可见的范围

变量的内存分配方式

栈变量 (Stack Variables)：

  • 存储在栈内存中，由运行时系统自动管理
  • 生命周期与作用域绑定，进入作用域时分配，离开时自动释放
  • 分配和释放速度快，但空间有限
  • 大小在编译时确定，不能动态调整
  • 典型例子：局部变量、函数参数

堆变量 (Heap Variables)：

  • 存储在堆内存中，需要手动管理(c++)或由垃圾回收器管理(js)
  • 生命周期独立于作用域
  • 空间较大，但分配和释放相对较慢
  • 大小支持动态调整
  • 典型例子：动态分配的对象、数组

静态存储期变量：

  • 内存地址在程序运行期间保持不变
  • 编译器或解释器在编译时确定地址
  • 生命周期通常与程序运行时间相同
  • 典型例子：全局变量、静态变量、字符串字面值、常量

常量

常量是值在程序运行期间不能被修改的变量，根据确定值的时机可以分为：

编译时常量 (Compile-time Constants)：

  • 值在编译时确定，编译后直接嵌入到机器码中
  • 不占用运行时内存空间
  • 编译器可以进行优化，如常量折叠
  • 典型例子：字面量、c++ constexpr、c++ 枚举值

运行时常量 (Runtime Constants)：

  • 值在运行时确定，但确定后不能修改
  • 占用运行时内存空间
  • 提供类型安全和运行时检查
  • 典型例子：c++ const

变量的作用域

作用域 (Scope) 定义了变量在程序中可见的范围。根据作用域规则的不同，可以分为静态作用域和动态作用域。

静态作用域/词法作用域 (Static Scope / Lexical Scope)：

  • 变量的可见性在编译时确定，由其在源代码中的位置决定
  • 支持嵌套作用域，内层作用域可以访问外层作用域的变量
  • 分类
    • 全局作用域：在整个程序中都可以访问
    • 函数作用域：只在定义它的函数内可访问
    • 块级作用域：只在定义它的代码块内可访问
    • 模块作用域：只在当前模块内可访问
  • 作用域链 (Scope Chain)：
    • 在静态作用域中，每个作用域都有一个指向其外层作用域的引用
    • 形成一条作用域链，用于变量查找
    • 变量查找沿着作用域链向上进行

动态作用域 (Dynamic Scope)：

  • 变量的可访问性在运行时确定，基于程序的调用栈(由函数的调用关系决定)
  • 变量查找沿着调用栈向上查找

静态作用域 vs 动态作用域对比：

特性静态作用域动态作用域
确定时机编译时运行时
查找方式基于代码结构基于调用栈
性能编译时优化运行时查找
可预测性高低
典型语言C, C++, Java, Python, JavaScriptLisp, Bash, Perl

静态作用域示例：

let x = 10;  // 全局变量

function outer() {
    let x = 20;  // 局部变量
    
    function inner() {
        let x = 30;  // 内层局部变量
        console.log(x);  // 输出：30（访问最近的x）
    }
    
    inner();
    console.log(x);  // 输出：20（访问外层的x）
}

outer();
console.log(x);  // 输出：10（访问全局的x）

动态作用域示例（伪代码）：

# Bash 示例（支持动态作用域）
x=10

function outer() {
    x=20
    inner
    echo $x  # 输出：30（因为inner修改了x）
}

function inner() {
    x=30
    echo $x  # 输出：30
}

outer
echo $x  # 输出：30（因为outer调用了inner）

变量类型

变量类型定义了变量可以存储的数据种类和格式

基础类型 (Primitive Types)

基础类型是编程语言内置的基本数据类型，直接对应计算机的底层数据类型。

整数类型 (Integer Types)：

  • char：字符类型，通常8位，可表示ASCII字符
  • short：短整型，通常16位
  • int：整型，通常32位，最常用的整数类型
  • long：长整型，通常32位或64位
  • long long：长长整型，通常64位

浮点类型 (Floating-point Types)：

  • float：单精度浮点型，通常32位
  • double：双精度浮点型，通常64位
  • long double：扩展精度浮点型，精度更高

布尔类型 (Boolean Type)：

  • bool：布尔类型，只有true和false两个值

字符类型 (Character Type)：

  • char：字符类型，存储单个字符
  • wchar_t：宽字符类型，支持Unicode

空类型 (Void Type)：

  • void：表示无类型，通常用于函数返回值或指针

复合类型 (Composite Types)

复合类型是由基础类型组合而成的复杂数据类型。

数组 (Array)：

  • 相同类型元素的连续存储
  • 固定大小，编译时确定
  • 支持索引访问

结构体 (Struct)：

  • 不同类型数据的组合
  • 自定义的数据结构
  • 支持成员访问

联合体 (Union)：

  • 共享内存的不同类型数据
  • 同一时刻只能使用一个成员
  • 节省内存空间

枚举 (Enum)：

  • 命名常量集合
  • 提高代码可读性
  • 类型安全

元组 (Tuple)：

  • 固定长度、固定类型的元素序列
  • 不可变或部分可变（取决于语言实现）
  • 类型安全，编译时检查类型匹配

常用容器类型 (Container Types)

现代编程语言提供了丰富的容器类型，用于管理数据集合。

序列容器 (Sequence Containers)：

  • 数组 (Array)：固定大小，连续存储
  • 向量 (Vector)：动态大小，连续存储
  • 列表 (List)：双向链表，支持快速插入删除
  • 双端队列 (Deque)：双端队列，两端快速操作

关联容器 (Associative Containers)：

  • 集合 (Set)：唯一元素集合，自动排序
  • 多重集合 (Multiset)：允许重复元素的集合
  • 映射 (Map)：键值对集合，键唯一
  • 多重映射 (Multimap)：允许重复键的映射

无序容器 (Unordered Containers)：

  • 无序集合 (Unordered Set)：基于哈希的集合
  • 无序映射 (Unordered Map)：基于哈希的映射

变量类型 - 指针

指针是存储内存地址的变量，它指向内存中的某个位置。指针提供了直接访问内存的能力，是底层编程的重要工具。

指针的基本概念：

  • 地址：指针存储的是内存地址
  • 解引用：通过指针访问指向的数据
  • 类型安全：指针有类型，限制其指向的数据类型

特殊的指针

空指针 (Null Pointer)：

  • 不指向任何有效内存地址
  • 用于表示"无效"或"未初始化"状态
  • 典型值：nullptr、NULL、0

悬空指针 (Dangling Pointer)：

  • 指向已经被释放的内存
  • 使用悬空指针会导致未定义行为
  • 常见原因：对象销毁后仍使用指针
int* ptr = malloc(sizeof(int));
*ptr = 42;
free(ptr);  // 内存被释放
*ptr = 100; // 野指针！访问已释放的内存

野指针 (Wild Pointer)：

  • 未初始化的指针
  • 包含随机内存地址
  • 使用野指针会导致未定义行为
int* ptr;  // 未初始化
*ptr = 42; // 野指针！ptr包含随机地址

智能指针 (Smart Pointer)：

  • 自动管理内存的指针
  • 防止内存泄漏和悬空指针
  • 典型实现：unique_ptr、shared_ptr、weak_ptr

C++ 指针可以指向的内容

C++ 指针具有强大的灵活性，可以指向多种类型的数据：

1. 变量/常量：基本类型、结构体/类

int value = 42;
int* ptr = &value;  // 指向int变量
*ptr = 100;         // 通过指针修改值

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr;           // 指向数组首地址
int* element_ptr = &arr[2];  // 指向特定元素

struct Person {
    string name;
    int age;
};

Person person = {"张三", 25};
Person* ptr = &person;
ptr->name = "李四";  // 通过指针访问成员

2. 函数：

int add(int a, int b) { return a + b; }
int (*func_ptr)(int, int) = add;  // 函数指针
int result = func_ptr(3, 4);      // 通过指针调用函数

3. 成员函数 成员变量

class Calculator {
public:
    int add(int a, int b) { return a + b; }
    int member;
};

Calculator calc;
int (Calculator::*member_func_ptr)(int, int) = &Calculator::add;
int result = (calc.*member_func_ptr)(3, 4);

int Calculator::*member_ptr = &Calculator::member;
Calculator obj;
obj.*member_ptr = 42;  // 通过成员指针访问

4. 指针本身（多级指针）：

int value = 42;
int* ptr1 = &value;
int** ptr2 = &ptr1;  // 指向指针的指针
**ptr2 = 100;        // 通过多级指针修改值

空变量

空变量是指没有有效值或未初始化的变量。空值经常意味着代码有问题，要检查变量是否为空值，保证空值安全。在不同编程语言中，空变量的概念和处理方式有所不同。包括了

  • 变量已声明但未赋值
  • 变量被显式设置为空值
  • 变量指向无效的内存地址
  • 变量包含默认的空值

不同语言中的空变量

C++ 中的空变量：

// 未初始化的变量（危险）
int uninitialized;  // 包含随机值

Java 中的空变量：

// 对象引用可以为null
String nullString = null;
Integer nullInteger = null;

JavaScript/TypeScript 中的空变量：

// 声明但未赋值
let undefinedVar;  // 值为 undefined
var oldStyleVar;   // 值为 undefined

Python 中的空变量：

# 空值
none_var = None

变量的其他形式

除了直接存储数据的变量外，编程语言中还存在其他形式的变量，它们可以存储函数、类、模块等更复杂的结构。

函数变量 (Function Variables)

函数变量是指将函数作为值存储在变量中，这是函数式编程的核心概念。

JavaScript/TypeScript 中的函数变量：

// 函数表达式
const add = function(a, b) {
    return a + b;
};

// 箭头函数
const multiply = (a, b) => a * b;

// 函数作为参数传递
function applyOperation(operation, x, y) {
    return operation(x, y);
}

const result = applyOperation(add, 5, 3);  // 8

// 函数作为返回值
function createCounter() {
    let count = 0;
    return function() {
        return ++count;
    };
}

const counter = createCounter();
console.log(counter());  // 1
console.log(counter());  // 2

Python 中的函数变量：

# 函数作为变量
def add(a, b):
    return a + b

operation = add  # 函数赋值给变量
result = operation(5, 3)  # 8

# 函数作为参数
def apply_operation(operation, x, y):
    return operation(x, y)

result = apply_operation(add, 5, 3)  # 8

# 函数作为返回值
def create_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

counter = create_counter()
print(counter())  # 1
print(counter())  # 2

# 匿名函数（lambda）
square = lambda x: x ** 2
result = square(4)  # 16

C++ 中的原生函数不是变量，lamada 函数是变量，其本质上是 struct

类变量 (Class Variables)

类变量是指将类作为值存储在变量中，这在面向对象编程中很常见。

JavaScript/TypeScript 中的类变量：

// 类作为变量
class Animal {
    constructor(name) {
        this.name = name;
    }
    
    speak() {
        console.log(`${this.name} makes a sound`);
    }
}

class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks`);
    }
}

// 类存储在变量中
const AnimalClass = Animal;
const DogClass = Dog;

// 使用类变量创建实例
const animal = new AnimalClass("Generic Animal");
const dog = new DogClass("Buddy");

// 类作为参数传递
function createInstance(ClassType, name) {
    return new ClassType(name);
}

const cat = createInstance(Animal, "Whiskers");

Python 中的类变量：

# 类作为变量
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} makes a sound")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks")

# 类存储在变量中
AnimalClass = Animal
DogClass = Dog

# 使用类变量创建实例
animal = AnimalClass("Generic Animal")
dog = DogClass("Buddy")

# 类作为参数传递
def create_instance(class_type, name):
    return class_type(name)

cat = create_instance(Animal, "Whiskers")

# 动态创建类
def create_animal_class(sound):
    class DynamicAnimal:
        def __init__(self, name):
            self.name = name
        
        def speak(self):
            print(f"{self.name} {sound}")
    
    return DynamicAnimal

CatClass = create_animal_class("meows")
cat = CatClass("Fluffy")

C++ 中的类不是变量

闭包变量

闭包变量是指被函数内部引用但在函数外部定义的变量。闭包允许函数"记住"其创建时的环境，包括外部作用域中的变量。

注意: javascript python 在闭包中捕获的 栈变量，会自动转为 堆变量，使其跟随 闭包始终存在

// 基本闭包
function createCounter() {
    let count = 0;  // 闭包变量
    return function() {
        return ++count;
    };
}

模块变量 (Module Variables)

模块变量是指将整个模块作为值存储在变量中，这在模块化编程中很常见。

JavaScript/TypeScript 中的模块变量：

// 模块作为变量
const fs = require('fs');  // Node.js 模块
const path = require('path');

// 动态导入模块
async function loadModule(moduleName) {
    const module = await import(moduleName);
    return module;
}

// 使用模块变量
const mathModule = await loadModule('./math.js');
const result = mathModule.add(5, 3);

// 模块作为参数传递
function useModule(module, operation, ...args) {
    return module[operation](...args);
}

const result2 = useModule(mathModule, 'multiply', 4, 5);

Python 中的模块变量：

import sys
import importlib

# 模块作为变量
import math
math_module = math

# 使用模块变量
result = math_module.sqrt(16)  # 4.0

# 动态导入模块
def load_module(module_name):
    return importlib.import_module(module_name)

# 使用动态加载的模块
os_module = load_module('os')
current_dir = os_module.getcwd()

# 模块作为参数传递
def use_module(module, operation, *args):
    func = getattr(module, operation)
    return func(*args)

result = use_module(math_module, 'pow', 2, 3)  # 8.0

其他特殊变量形式

生成器变量 (Generator Variables)：

# Python 生成器
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 生成器作为变量
fib_gen = fibonacci()

# 使用生成器变量
for i in range(10):
    print(next(fib_gen), end=" ")  # 0 1 1 2 3 5 8 13 21 34

语言特性

TypeScript

  • 声明定义初始化在一起。未赋值变量为 undefined
  • javascript 中 var 定义的变量会被提升。即在下面定义了，上面也能使用
  • let const 有暂时性死区的概念
  • 没有 let const var 声明的变量，相当于用 var 声明的变量
  • 闭包内捕获的基础类型变量是堆变量，否则栈变量；非基础类型变量需要用 new 创建，是堆变量。
  • 栈变量只存储变量引用。实际数据在堆中存储。

JavaScript 中的变量声明：

// 变量提升 (Hoisting)
console.log(hoistedVar);  // undefined（不是错误）

// console.log(test);  // ReferenceError

var hoistedVar = "Hello";

// 暂时性死区 (Temporal Dead Zone)
// console.log(tdzVar);  // ReferenceError
let tdzVar = "Hello";

// 函数声明提升
hoistedFunction();  // 正常工作
function hoistedFunction() {
    console.log("函数被提升");
}

Python

  • 变量不需要标识符声明。
  • 基础类型也是对象。栈变量指向存储在堆中对象的引用
  • 变量声明定义初始化在一起。未赋值变量为 None
  • 闭包内捕获的基础类型变量是堆变量，否则栈变量；非基础类型变量是堆变量。
  • 函数内的同名变量，默认会重新创建，是局部变量。除非用 global nolocal 声明，此时的变量是外面定义的变量

Python 中的变量作用域：

# Python 中变量必须先定义再使用
# print(undefined_var)  # NameError: name 'undefined_var' is not defined

# 在函数中使用全局变量
global_var = 10

def function():
    # print(global_var)  # 如果下面有 local_var = 20，这里会报错（UnboundLocalError: cannot access local variable 'global_var' where it is not associated with a value）
    global_var = 20 # 此时 global_var 是局部变量
    print(global_var)  # 正常工作

function()

C++

  • 未初始化的变量是未定义行为
extern int global_var;  // 声明
int x;                  // 声明定义
x = 10;                 // 初始化
x = 20;                 // 更新

int y{};               // 声明定义初始化   
// 离开作用域时销毁
  • 堆变量需要特殊构造(new、malloc)
  • 作用域自动识别

运算与表达式

运算包括算术运算、比较运算、逻辑运算、位运算等。

特性TypeScriptPythonC++
算术运算+ - * / % **+ - * / // % **+ - * / %
比较运算== === != !==== != < > <= >=== != < > <= >=
逻辑运算&& || !and or not&& || !
位运算& | ^ ~ << >>& | ^ ~ << >>& | ^ ~ << >>

流程控制

流程控制包括条件判断和循环结构。

特性TypeScriptPythonC++
if语句if/else if/elseif/elif/elseif/else if/else
switch语句switch/casematch (3.10+)switch/case
for循环for/in, for/offor/in, range()for, while
while循环whilewhilewhile
循环控制break/continuebreak/continuebreak/continue

函数

函数是代码复用的基本单位。执行输入(参数)和输出(返回)

函数类型

  • 匿名函数是没有名称的函数，通常用于需要函数作为参数或返回值的场景

Python 匿名函数示例：

# Lambda 表达式（匿名函数）
add = lambda a, b: a + b

C++ 匿名函数示例（Lambda表达式）：

#include <vector>
#include <algorithm>

// Lambda 表达式（匿名函数）
auto add = [](int a, int b) { return a + b; };

闭包

闭包就是能够读取其他函数内部变量的函数

闭包的核心概念：

  • 词法作用域：函数可以访问其定义时所在作用域的变量
  • 变量捕获：内部函数捕获外部函数的变量
  • 状态保持：闭包中的变量状态在函数调用之间保持

TypeScript 闭包示例：

// 基本闭包
function createCounter() {
    let count = 0;  // 闭包变量
    return function() {
        return ++count;
    };
}

Python 闭包示例：

# 基本闭包
def create_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

C++ 闭包示例（Lambda表达式）：

#include <functional>

// Lambda 闭包
auto createCounter() {
    int count = 0;
    return [count]() mutable {
        return ++count;
    };
}

TypeScript 匿名函数示例：

// 箭头函数（匿名函数）
const add = (a: number, b: number) => a + b;

// 函数表达式
const multiply = function(a: number, b: number) {
    return a * b;
};
特性JavaScript/TypeScriptPythonC++
语法支持原生支持原生支持Lambda表达式
变量捕获自动捕获需要nonlocal声明显式捕获
内存管理自动垃圾回收自动垃圾回收RAII
性能开销中等中等低
调试难度中等中等困难
典型应用模块模式、回调装饰器、函数工厂状态管理

参数: 默认参数/函数重载/可变参数

TypeScript 示例：

// 默认参数
function greet(name: string = "World"): string {
    return `Hello, ${name}!`;
}

// 可变参数
function sum(...numbers: number[]): number {
    return numbers.reduce((acc, num) => acc + num, 0);
}

# 不支持函数重载

Python 示例：

# 默认参数
def greet(name="World"):
    return f"Hello, {name}!"

# 可变参数
def sum_numbers(*numbers):
    return sum(numbers)

# 关键字参数
def create_person(name, age, **kwargs):
    person = {"name": name, "age": age}
    person.update(kwargs)
    return person

# 不支持函数重载

C++ 示例：

// 默认参数
string greet(string name = "World") {
    return "Hello, " + name + "!";
}

// 不支持可变参数

// 函数重载
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

函数式编程

函数式编程将计算过程视为数学函数的求值，避免状态和可变数据。

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);
const sum = numbers.reduce((acc, x) => acc + x, 0);

类 和 对象

**类（Class）**是创建对象的模板或蓝图，定义了对象的属性和方法。类是一个抽象的概念，描述了具有相同特征和行为的对象的集合。

**对象（Object）**是类的实例，是类的具体表现。对象具有类定义的属性和方法，是程序运行时在内存中实际存在的数据结构。

三大特性

  • 封装: 将数据和方法绑定在一起，隐藏内部实现细节，只提供公共接口。
  • 继承: 子类继承父类的属性和方法，支持代码重用，建立类之间的层次关系。
  • 多态: 同一个接口可以有多种实现，支持方法重载和重写，提高代码的灵活性。

运行时内存布局

不同编程语言采用不同的机制来实现继承和多态，下面通过 运行时 的内存布局来理解 继承和多态 的实现。

Java

类信息（存储在方法区）：

  • 方法表：存储该类所有方法的地址
  • 父类引用：指向父类的类信息
  • 字段信息：字段名称、类型、偏移量等
  • 常量池：字符串常量、数字常量等

对象信息（存储在堆区）：

  • 对象头：包含指向类信息的指针、锁信息、GC信息
  • 实例字段：父类字段 + 子类字段（按顺序排列）
// 示例
public class Animal {
    protected int age;
    public void makeSound() { } // 虚方法
    public final void eat() { } // 非虚方法
    public static void staticMethod() { }  // 非虚方法（static）
    private void privateMethod() { }  // 非虚方法（private）
}

public class Dog extends Animal {
    private String name;
    public void bark() { }

    @Override
    public void makeSound() { }
}

Dog dog = new Dog();

// 内存布局详细说明
// 类加载阶段 - 方法区（Method Area）
Animal.class = {
    // 类元数据
    "name": "Animal",
    "superclass": Object.class,
    "interfaces": [],
    
    // 静态字段
    "staticFields": {},
    
    // 实例字段表
    "instanceFields": {
        "age": {
            "type": "int",
            "accessFlags": "protected",
            "offset": 12
        }
    },
    
    // 方法表
    "methods": {
        "eat": {
            "bytecode": <字节码>,
            "accessFlags": "public",
            "parameters": [],
            "returnType": "void"
        },
        "makeSound": {
            "bytecode": <字节码>,
            "accessFlags": "public", 
            "parameters": [],
            "returnType": "void"
        },
        "<init>": {  // 构造函数
            "bytecode": <字节码>,
            "parameters": []
        }
    },
    
    // 虚方法表（vtable）
    "vtable": [
        "makeSound" -> Animal.makeSound,
        "toString" -> Object.toString,
        // ... 其他虚方法
    ]
}

Dog.class = {
    // 类元数据
    "name": "Dog", 
    "superclass": Animal.class,
    "interfaces": [],
    
    // 静态字段
    "staticFields": {},
    
    // 实例字段表（继承 + 新增）
    "instanceFields": {
        "age": {  // 继承自Animal
            "type": "int",
            "accessFlags": "protected", 
            "offset": 12
        },
        "name": {  // 新增字段
            "type": "String",
            "accessFlags": "private",
            "offset": 16
        }
    },
    
    // 方法表
    "methods": {
        "bark": {
            "bytecode": <字节码>,
            "accessFlags": "public",
            "parameters": [],
            "returnType": "void"
        },
        "makeSound": {  // 重写方法
            "bytecode": <字节码>,
            "accessFlags": "public",
            "parameters": [],
            "returnType": "void"
        },
        "<init>": {  // 构造函数
            "bytecode": <字节码>,
            "parameters": []
        }
    },
    
    // 虚方法表（vtable）
    "vtable": [
        "makeSound" -> Dog.makeSound,  // 重写的方法
        "eat" -> Animal.eat,           // 继承的方法
        "bark" -> Dog.bark,            // 新增的方法
        "toString" -> Object.toString,
        // ... 其他虚方法
    ]
}

// 堆内存中的对象布局
dog = {
    // 对象头（Object Header）
    "markWord": {
        "hashCode": 0x12345678,
        "age": 0,
        "lockState": "unlocked",
        "gcMark": false
    },
    "klassPointer": Dog.class,  // 指向Dog类的指针
    
    // 实例数据（Instance Data）
    "age": 0,      // 默认值，偏移量12
    "name": null   // 默认值，偏移量16
}

// 虚方法调用示例
dog.makeSound();  // 虚方法调用

// 调用过程：
// 1. 获取对象的 klassPointer -> Dog.class
// 2. 在Dog.class的vtable中查找makeSound
// 3. 找到Dog.makeSound的实现
// 4. 执行方法

// 非虚方法调用
dog.bark();  // 非虚方法调用，编译时确定

// 静态方法调用
Dog.staticMethod();  // 编译时确定，不涉及对象

C++

类信息（存储在代码段）：

  • 虚函数表（vtable）：存储虚函数的地址（只存储虚函数，不包括普通成员函数）
  • 类型信息（RTTI）：运行时类型信息，用于dynamic_cast
  • 静态成员：存储在数据段
  • 成员函数：存储在代码段

对象信息（存储在栈或堆）：

  • 对象头：包含虚函数表指针（如果有虚函数）
  • 实例字段：按声明顺序排列，包括继承的字段
// 示例
class Animal {
protected:
    int age;
public:
    void eat() { }           // 普通成员函数，不存储在vtable中
    virtual void makeSound() { }  // 虚函数，存储在vtable中
    virtual ~Animal() { }    // 虚析构函数，存储在vtable中
};

class Dog : public Animal {
private:
    std::string name;
public:
    void bark() { }          // 普通成员函数，不存储在vtable中
    void makeSound() override { }  // 重写虚函数，替换父类的虚函数地址
};

Dog* dog = new Dog();

// Dog对象在内存中的布局：
// [vptr] + [age] + [name]
// vptr：虚函数表指针，指向Dog的虚函数表

// 虚函数表结构：
// Animal的虚函数表：[Animal::makeSound地址] + [Animal::~Animal地址]
// Dog的虚函数表：[Dog::makeSound地址] + [Dog::~Dog地址]
// 注意：eat()和bark()是普通成员函数，不存储在vtable中

// 方法调用机制：
// 1. 虚函数调用（如dog->makeSound()）：
//    - 通过vptr找到虚函数表
//    - 在虚函数表中查找makeSound的地址
//    - 调用该地址的函数（动态绑定）
//
// 2. 普通成员函数调用（如dog->eat() dog->bark()）：
//    - 编译时确定函数地址
//    - 直接调用（静态绑定）

// 继承的虚函数处理：
// - 如果子类重写了虚函数，vtable中存储子类的函数地址
// - 如果子类没有重写虚函数，vtable中存储父类的函数地址
// - 子类新增的虚函数会添加到vtable末尾

JavaScript

类信息（存储在堆区）：

  • 原型链：通过__proto__属性链接到父类的原型对象
  • 构造函数：指向创建对象的函数
  • 方法：存储在原型对象上
  • 静态成员：存储在构造函数对象上

对象信息（存储在堆区）：

  • 属性表：存储实例属性和方法
  • 原型指针：指向原型对象
  • 构造函数指针：指向构造函数
// 示例
class Animal {
    constructor(age) {
        this.age = age;
    }
    
    eat() { }
    makeSound() { }
}

class Dog extends Animal {
    constructor(age, name) {
        super(age);
        this.name = name;
    }
    
    bark() { }
    makeSound() { }  // 重写方法
}

const dog = new Dog(5, "Buddy");

// 内存布局详细说明
// Object.prototype = {
//     __proto__: null 
// }
// Animal.prototype = {
//     eat: <function>,
//     makeSound: <function>,
//     constructor: Animal
//     __proto__: Object.prototype
// }
//
// Dog.prototype = {
//     bark: <function>,
//     makeSound: <function>,  // 重写了父类方法
//     constructor: Dog,
//     __proto__: Animal.prototype 
// }
//
// dog = {
//     age: 5,
//     name: "Buddy",
//     __proto__: Dog.prototype
// }

// 继承实现：通过原型链实现继承
// Dog.prototype = Object.create(Animal.prototype)
// 子类可以访问父类原型上的所有方法和属性

// 多态实现：通过原型链查找实现动态绑定
// 调用dog.makeSound()时：
// 1. 在dog对象上查找makeSound
// 2. 如果没找到，在Dog.prototype上查找
// 3. 如果没找到，在Animal.prototype上查找
// 4. 找到后调用该方法

Python

类信息（存储在堆区）：

  • 类字典（dict）：存储类属性和方法
  • 方法/属性查找顺序（MRO）：确定方法和属性的查找顺序
  • 元类信息：类的类型信息
  • 基类信息：父类列表

对象信息（存储在堆区）：

  • 实例字典（dict）：存储实例属性
  • 类指针：指向类对象
  • 槽位（slots）：如果定义了__slots__，则使用槽位存储
# 示例
class Animal:
    def __init__(self, age):
        self.age = age
    
    def eat(self):
        pass
    
    def make_sound(self):
        pass

class Dog(Animal):
    def __init__(self, age, name):
        super().__init__(age)
        self.name = name
    
    def bark(self):
        pass
    
    def make_sound(self):  # 重写方法
        pass

dog = Dog(5, "Buddy")

# 内存布局详细说明
Animal = {
    '__name__': 'Animal',
    '__bases__': (object,),
    '__dict__': {
        '__init__': <function Animal.__init__>,
        'eat': <function Animal.eat>,
        'make_sound': <function Animal.make_sound>,
        '__module__': '__main__',
        '__doc__': None
    },
    '__class__': <class 'type'>,
    '__mro__': (Animal, object)
}

Dog = {
    '__name__': 'Dog', 
    '__bases__': (Animal,),
    '__dict__': {
        '__init__': <function Dog.__init__>,
        'bark': <function Dog.bark>,
        'make_sound': <function Dog.make_sound>,  # 重写了父类方法
        '__module__': '__main__',
        '__doc__': None
    },
    '__class__': <class 'type'>,
    '__mro__': (Dog, Animal, object)
}

# 实例化后的内存布局
dog = {
    '__class__': Dog,
    '__dict__': {
        'age': 5,
        'name': "Buddy"
    },
    '__weakref__': None,
    '__slots__': None
}

# 查找链: 按照 MRO 顺序查找
# dog.属性名 -> dog.__dict__ -> Dog.__dict__ -> Animal.__dict__ -> object.__dict__

# Dog.__mro__ = (Dog, Animal, object)

# 当调用 dog.eat() 时：
# 1. dog.__dict__ 中没有 eat
# 2. Dog.__dict__ 中没有 eat  
# 3. Animal.__dict__['eat'] -> 找到！执行父类方法

内存布局对比

特性JavaC++JavaScriptPython
类信息存储方法区代码段堆区堆区
对象存储堆区栈/堆堆区堆区
继承实现类继承类继承原型链MRO
多态实现虚函数表虚函数表原型链MRO
内存管理GC手动/RAIIGCGC
类型安全强类型强类型弱类型强类型
运行时类型RTTIRTTItypeoftype()
方法绑定动态绑定虚函数表原型链MRO
内存开销中等低高高
性能高最高中等中等

多重继承 vs 单继承

多重继承允许一个类继承多个父类，单继承只允许继承一个父类。

特性多重继承单继承
继承数量多个父类一个父类
复杂性高（钻石问题）低
灵活性高相对较低
维护难度困难简单
典型语言C++, PythonJava, C#

多重继承示例：

# Python - 多重继承
class Animal:
    def make_sound(self):
        pass

class Flyable:
    def fly(self):
        pass

class Bird(Animal, Flyable):  # 多重继承
    def make_sound(self):
        print("Tweet!")
    
    def fly(self):
        print("Flying...")

单继承示例：

// Java - 单继承
public abstract class Animal {
    public abstract void makeSound();
}

public class Bird extends Animal {  // 只能继承一个类
    @Override
    public void makeSound() {
        System.out.println("Tweet!");
    }
}

接口 vs 抽象类

接口定义契约，抽象类提供部分实现。

特性接口抽象类
实现无实现部分实现
继承可多继承单继承
构造函数无有
字段常量实例字段
访问修饰符公共任意

接口示例：

// Java - 接口
public interface Drawable {
    void draw();  // 抽象方法
    default void resize() {  // 默认方法
        System.out.println("Resizing...");
    }
}

public class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing circle");
    }
}

// TypeScript - 接口
interface Drawable {
    draw(): void;
    resize?(): void;  // 可选方法
}

class Circle implements Drawable {
    draw(): void {
        console.log("Drawing circle");
    }
}

抽象类示例：

// Java - 抽象类
public abstract class Shape {
    protected double area;  // 实例字段
    
    public abstract void calculateArea();  // 抽象方法
    
    public void display() {  // 具体方法
        System.out.println("Area: " + area);
    }
}

public class Circle extends Shape {
    private double radius;
    
    @Override
    public void calculateArea() {
        area = Math.PI * radius * radius;
    }
}

访问控制

不同编程语言提供不同级别的访问控制。

访问级别Java/C#C++PythonTypeScript
公共publicpublic无前缀public
私有privateprivate_前缀private
受保护protectedprotected约定protected
包级packagefriend模块级无

访问控制示例：

// Java - 访问控制
public class BankAccount {
    private double balance;  // 私有字段
    protected String accountNumber;  // 受保护字段
    
    public void deposit(double amount) {  // 公共方法
        if (amount > 0) {
            balance += amount;
        }
    }
    
    private void validateAmount(double amount) {  // 私有方法
        if (amount < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
    }
}

# Python - 访问控制（约定）
class BankAccount:
    def __init__(self):
        self._balance = 0  # 约定私有
        self.__account_number = "12345"  # 名称改写私有
    
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
    
    def _validate_amount(self, amount):  # 约定私有方法
        if amount < 0:
            raise ValueError("Amount cannot be negative")

构造函数

不同语言对构造函数的支持不同。

特性Java/C#C++PythonTypeScript
构造函数名类名类名initconstructor
重载支持支持不支持支持
默认构造函数自动生成自动生成无自动生成
初始化列表无有无无

构造函数示例：

// Java - 构造函数重载
public class Person {
    private String name;
    private int age;
    
    public Person() {  // 默认构造函数
        this.name = "Unknown";
        this.age = 0;
    }
    
    public Person(String name) {  // 重载构造函数
        this.name = name;
        this.age = 0;
    }
    
    public Person(String name, int age) {  // 重载构造函数
        this.name = name;
        this.age = age;
    }
}

// C++ - 构造函数和初始化列表
class Person {
private:
    std::string name;
    int age;
    
public:
    Person() : name("Unknown"), age(0) {}  // 初始化列表
    
    Person(const std::string& name) : name(name), age(0) {}
    
    Person(const std::::string& name, int age) : name(name), age(age) {}
};

# Python - 构造函数
class Person:
    def __init__(self, name="Unknown", age=0):  # 默认参数
        self.name = name
        self.age = age
    
    # Python不支持构造函数重载，但可以通过默认参数实现类似效果

方法重载 vs 方法重写

方法重载是编译时多态，方法重写是运行时多态。

特性方法重载方法重写
时机编译时运行时
签名不同参数相同签名
继承同一类内父子类间
绑定静态绑定动态绑定

方法重载示例：

// Java - 方法重载
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {  // 重载
        return a + b;
    }
    
    public int add(int a, int b, int c) {  // 重载
        return a + b + c;
    }
}

方法重写示例：

// Java - 方法重写
public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {  // 重写父类方法
        System.out.println("Woof!");
    }
}

静态成员 vs 实例成员

静态成员属于类，实例成员属于对象。

特性静态成员实例成员
访问方式类名.成员对象.成员
内存分配类加载时对象创建时
生命周期程序运行期对象生命周期
数据共享所有对象共享每个对象独立

静态成员示例：

// Java - 静态成员
public class Counter {
    private static int count = 0;  // 静态字段
    private int instanceId;
    
    public Counter() {
        instanceId = ++count;  // 使用静态字段
    }
    
    public static int getCount() {  // 静态方法
        return count;
    }
    
    public int getInstanceId() {
        return instanceId;
    }
}

# Python - 静态成员
class Counter:
    count = 0  # 类变量（静态字段）
    
    def __init__(self):
        Counter.count += 1
        self.instance_id = Counter.count
    
    @classmethod
    def get_count(cls):  # 类方法（静态方法）
        return cls.count

类型

静态类型 vs 动态类型

静态类型语言在编译时检查类型；动态类型语言在运行时检查类型，定义之后，可以改变。

特性静态类型动态类型
类型检查时机编译时运行时
错误发现提前发现运行时发现
性能通常更好通常较差
开发速度相对较慢相对较快
IDE支持更好相对较差
典型语言Java, C++, Rust，TypescriptPython, JavaScript, Ruby

静态类型示例：

String name = "张三";
int age = 25;
// 编译时检查类型

动态类型示例：

a: int = 1
a = "abc"
# 运行时检查类型

注意:

  • python 的类型只是一个提示。定义后可以随意更改

强类型 vs 弱类型

强类型语言有严格的类型检查，弱类型语言允许宽松的类型转换。

特性强类型弱类型
类型转换显式转换隐式转换
类型安全更安全可能出错
灵活性相对较低相对较高
典型语言Python, JavaC, JavaScript

强类型示例：

# Python 强类型
x = "5"
y = int(x) + 3  # 需要显式转换

弱类型示例：

// JavaScript 弱类型
var x = "5";
var y = x + 3;  // 自动转换为字符串 "53"

类型推断（Type Inference）

类型推断允许编译器或解释器根据上下文自动推断变量的类型，而不需要程序员显式声明类型。

auto a = 1;

类型检查 (Type Checking)

类型判断确保程序中的类型使用是正确的，包括：

  • 静态类型检查：编译时检查类型匹配
  • 动态类型检查：运行时检查类型匹配

编译时类型检查示例：

// C++ - 编译时检查
template<typename T>
void processUser(const T& user) {
    // 编译时类型检查
    static_assert(std::is_same_v<T, User>, "T must be User");
}

运行时类型检查示例：

// TypeScript - 运行时检查
function processData(data: unknown): void {
    // 运行时类型检查
    if (typeof data === 'string') {
        console.log('String:', data.toUpperCase());
    } else if (typeof data === 'number') {
        console.log('Number:', data.toFixed(2));
    } else if (Array.isArray(data)) {
        console.log('Array:', data.length);
    }
}

类型编程

类型编程是指在编译时使用类型系统进行计算和操作，将类型本身作为编程的对象。从语言设计者的角度来看，一个完整的类型系统需要包含以下核心要素：

类型定义 (Type Definition)

类型定义是类型系统的基础，决定了如何创建和声明新的类型。

基本类型定义：

  • 内置类型：语言提供的基础类型（int、string、bool等）
  • 用户定义类型：程序员自定义的类型（struct、class、interface等）
  • 类型别名：为现有类型创建新的名称
  • 字面量类型：具体的值也可以作为类型
// 基本类型
type Number = number;

// 用户定义类型
interface User {
    id: number;
    name: string;
}

// 类型别名
type UserId = number;

// 字面量类型 - 具体的值作为类型
type NumberOne = 1;
type Numbers = [1, 2, 3, 4, 5];

# Python - 类型定义
from typing import TypeAlias

Number: TypeAlias = int
UserId: TypeAlias = int
NumberOne: TypeAlias = Literal[1]  # 字面量类型

class User:
    def __init__(self, id: int, name: str):
        self.id = id
        self.name = name

类型关系 (Type Relationships)

定义类型之间的关系，包括：

  • 类型继承：子类型与父类型的关系
  • 联合类型：多个类型中的任意一个
  • 交叉类型：多个类型的组合
// 类型继承
interface AdminUser extends User {
    permissions: string[];
}

// 交叉类型
type UserWithEmail = User & { email: string };

// 联合类型
type Status = "active" | "inactive" | "pending";

类型计算 (Type Computation)

在编译时进行类型级别的计算：

  • 条件类型：根据条件选择不同类型
  • 类型映射：批量转换类型结构
  • 类型推断：从现有类型推导出新类型
  • 类型递归：递归地处理复杂类型结构
// 条件类型
type IsString<T> = T extends string ? true : false;

// 类型映射
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

// 类型推断
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

// 递归类型
type DeepReadonly<T> = {
    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

反射 (Reflection)

反射是程序在运行时或编译时检查、内省和修改自身结构与行为的能力。反射机制允许程序获取类型信息、调用方法、访问字段，以及动态创建对象等操作。

不同编程语言对反射的支持程度和实现方式各不相同：

特性JavaScriptPythonJavaC++
反射时机运行时运行时运行时编译时(C++26)
类型检查typeof, instanceoftype(), isinstance()getClass()std::meta (C++26)
动态调用原生支持getattr(), setattr()Method.invoke()不支持
动态创建原生支持globals(), locals()Class.newInstance()不支持
字段访问原生支持hasattr()Field.get/set()std::meta (C++26)
性能开销中等中等高无(编译时)

JavaScript 反射

JavaScript 作为动态语言，天然支持强大的反射能力。

基本反射操作：

// 类型检查
console.log(typeof 42);        // "number"
console.log(typeof "hello");   // "string"
console.log(Array.isArray([])); // true

// 对象属性检查
const user = { name: "张三", age: 25 };
console.log("name" in user);           // true
console.log(user.hasOwnProperty("age")); // true
console.log(Object.keys(user));         // ["name", "age"]

// 动态属性访问
const propName = "name";
console.log(user[propName]);  // "张三"
user[propName] = "李四";      // 动态赋值

// 动态方法调用
const obj = {
    greet(name) { return `Hello, ${name}!`; }
};
console.log(obj["greet"]("世界")); // "Hello, 世界!"

高级反射特性：

// Proxy - 元编程
const userProxy = new Proxy(user, {
    get(target, prop) {
        console.log(`访问属性: ${prop}`);
        return target[prop];
    },
    set(target, prop, value) {
        console.log(`设置属性: ${prop} = ${value}`);
        target[prop] = value;
        return true;
    }
});

// Reflect API
console.log(Reflect.has(user, "name"));    // true
Reflect.set(user, "email", "zhang@example.com");
console.log(Reflect.ownKeys(user));        // ["name", "age", "email"]

// 动态函数创建
const dynamicFunction = new Function("a", "b", "return a + b");
console.log(dynamicFunction(2, 3)); // 5

Python 反射

Python 提供了丰富的反射功能，通过内置函数和特殊方法实现。

基本反射操作：

# 类型检查
print(type(42))                    # <class 'int'>
print(isinstance(42, int))         # True
print(hasattr(obj, "method_name")) # 检查是否有某个属性

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, {self.name}!"

user = User("张三", 25)

# 动态属性访问
print(getattr(user, "name"))           # "张三"
setattr(user, "email", "zhang@example.com")
print(hasattr(user, "email"))          # True

# 获取对象信息
print(dir(user))                       # 列出所有属性和方法
print(vars(user))                      # 返回对象的__dict__

高级反射特性：

import inspect

# 动态方法调用
method_name = "greet"
method = getattr(user, method_name)
print(method())  # "Hello, 张三!"

# 函数信息检查
def example_func(a: int, b: str = "default") -> str:
    return f"{a}: {b}"

sig = inspect.signature(example_func)
print(sig.parameters)  # 参数信息
print(sig.return_annotation)  # 返回类型注解

# 动态类创建
DynamicClass = type("DynamicClass", (object,), {
    "class_attr": "value",
    "method": lambda self: "dynamic method"
})

instance = DynamicClass()
print(instance.method())  # "dynamic method"

# 模块反射
import sys
module = sys.modules[__name__]
print(getattr(module, "User"))  # 获取模块中的类

Java 反射

Java 提供了完整的反射API，运行时能够检查和操作类、方法、字段等。

基本反射操作：

// 类信息获取
Class<?> clazz = String.class;
System.out.println(clazz.getName());        // "java.lang.String"
System.out.println(clazz.getSuperclass());  // class java.lang.Object

// 运行时获取类信息
Object obj = "Hello";
Class<?> objClass = obj.getClass();
System.out.println(objClass.getSimpleName()); // "String"

// 字段反射
class User {
    private String name;
    public int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void greet() {
        System.out.println("Hello, " + name);
    }
}

Class<?> userClass = User.class;
Field[] fields = userClass.getDeclaredFields();
for (Field field : fields) {
    System.out.println(field.getName() + ": " + field.getType());
}

高级反射特性：

import java.lang.reflect.*;

// 动态对象创建
Constructor<?> constructor = userClass.getConstructor(String.class, int.class);
Object userInstance = constructor.newInstance("张三", 25);

// 动态方法调用
Method greetMethod = userClass.getMethod("greet");
greetMethod.invoke(userInstance); // 调用方法

// 动态字段访问
Field nameField = userClass.getDeclaredField("name");
nameField.setAccessible(true); // 访问私有字段
System.out.println(nameField.get(userInstance)); // 获取字段值
nameField.set(userInstance, "李四");              // 设置字段值

// 注解反射
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value();
}

@MyAnnotation("test")
class AnnotatedClass { }

MyAnnotation annotation = AnnotatedClass.class.getAnnotation(MyAnnotation.class);
System.out.println(annotation.value()); // "test"

C++ 反射

C++传统上不支持运行时反射，但C++26将引入编译时反射，这是一个革命性的特性。

C++26 编译时反射：

#include <experimental/meta>
#include <iostream>
#include <string>

struct User {
    std::string name;
    int age;
    double salary;
};

// 编译时反射 - 获取结构体信息
template<typename T>
constexpr void print_struct_info() {
    std::cout << "结构体 " << std::meta::identifier_of(^T) << " 的成员:\n";
    
    // 遍历所有非静态数据成员
    [:expand(std::meta::nonstatic_data_members_of(^T)):] >> []<auto member> {
        using member_type = typename[:std::meta::type_of(member):];
        
        std::cout << "  " << std::meta::identifier_of(member)
                  << " : " << std::meta::identifier_of(^member_type) << "\n";
    };
}

// 编译时序列化
template<typename T>
constexpr std::string struct_to_json(const T& obj) {
    std::string result = "{";
    bool first = true;
    
    [:expand(std::meta::nonstatic_data_members_of(^T)):] >> [&]<auto member> {
        if (!first) result += ",";
        first = false;
        
        result += "\"" + std::string(std::meta::identifier_of(member)) + "\":";
        
        using member_type = typename[:std::meta::type_of(member):];
        auto value = obj.[:member:];
        
        if constexpr (std::same_as<member_type, std::string>) {
            result += "\"" + value + "\"";
        } else if constexpr (std::is_arithmetic_v<member_type>) {
            result += std::to_string(value);
        }
    };
    
    result += "}";
    return result;
}

int main() {
    print_struct_info<User>();
    
    User user{"张三", 30, 50000.0};
    std::cout << struct_to_json(user) << std::endl;
    // 输出: {"name":"张三","age":30,"salary":50000.000000}
    
    return 0;
}

传统C++的反射替代方案：

// 使用宏和模板实现简单反射
#define REFLECT_STRUCT(name, ...) \
    struct name { \
        __VA_ARGS__ \
        static constexpr auto member_names() { \
            return std::array{#__VA_ARGS__}; \
        } \
    }

// 使用RTTI进行运行时类型检查
#include <typeinfo>

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base { };

void checkType(Base* obj) {
    if (typeid(*obj) == typeid(Derived)) {
        std::cout << "对象是 Derived 类型" << std::endl;
    }
    
    // 动态类型转换
    if (Derived* d = dynamic_cast<Derived*>(obj)) {
        std::cout << "成功转换为 Derived" << std::endl;
    }
}

反射的应用场景

  1. 序列化/反序列化：自动将对象转换为JSON、XML等格式
  2. ORM框架：对象关系映射，自动生成SQL语句
  3. 依赖注入：根据类型信息自动注入依赖
  4. API文档生成：根据代码结构自动生成文档
  5. 单元测试：动态发现和执行测试方法
  6. 配置绑定：将配置文件内容绑定到对象属性

工程化

工程化是指将编程语言应用于实际项目开发时的最佳实践和工具链。良好的工程化实践能够提高代码质量、开发效率和项目可维护性。

注释

注释是代码中用于解释和说明的非执行文本，帮助其他开发者理解代码的意图和逻辑。

单行注释：

/**
 * 多行注释
 * /
// JavaScript 单行注释
let name = "张三";  // 用户姓名

异常

异常处理是程序运行时错误管理的重要机制，允许程序在遇到错误时优雅地处理并继续执行。

捕获异常

try-catch 结构：

// JavaScript 异常处理
try {
    const result = divide(10, 0);
    console.log(result);
} catch (error) {
    console.error("发生错误:", error.message);
} finally {
    console.log("清理资源");
}

自定义异常

// JavaScript 自定义异常
class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
    }
}

function validateAge(age) {
    if (age < 0 || age > 150) {
        throw new ValidationError("年龄必须在0-150之间");
    }
    return age;
}

文件组织

文件组织是指如何将代码文件按照逻辑结构进行组织和分类，以提高代码的可读性和可维护性。

JavaScript 模块：

// user.js
export class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
    }
}

export function validateUser(user) {
    return user.name && user.email;
}

// main.js
import { User, validateUser } from './user.js';

包管理

包管理是管理项目依赖的工具，包括安装、更新、删除第三方库。

npm (Node.js)：

// package.json
{
  "name": "my-project",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.0",
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "jest": "^29.0.0"
  }
}

测试

测试是验证代码正确性的重要手段，包括单元测试、集成测试、模糊测试等。

单元测试

JavaScript (Jest)：

// user.test.js
import { User } from './user.js';

describe('User', () => {
    test('should create user with valid data', () => {
        const user = new User(1, "张三", "zhang@example.com");
        expect(user.name).toBe("张三");
        expect(user.email).toBe("zhang@example.com");
    });
});

文档

文档是项目的重要组成部分，帮助开发者理解和使用代码。

JSDoc (JavaScript)：

/**
 * 用户类，表示系统中的用户
 * @class User
 */
class User {
    /**
     * 创建用户实例
     * @param {number} id - 用户ID
     * @param {string} name - 用户姓名
     * @param {string} email - 用户邮箱
     */
    constructor(id, name, email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }
}

代码规范

代码规范确保团队成员编写的代码风格一致，提高代码可读性。

命名规范

  • 变量名：使用有意义的名称，避免缩写
  • 函数名：使用动词开头，描述功能
  • 类名：使用名词，首字母大写
  • 常量名：全大写，下划线分隔

格式规范

JavaScript (ESLint)：

// 使用2个空格缩进
function calculateTotal(items) {
  let total = 0;
  for (const item of items) {
    total += item.price;
  }
  return total;
}

持续集成/持续部署 (CI/CD)

CI/CD 是自动化构建、测试和部署代码的实践。

  1. 代码提交：开发者提交代码到版本控制
  2. 自动构建：CI 系统自动构建项目
  3. 自动测试：运行单元测试、集成测试
  4. 代码质量检查：静态代码分析、代码覆盖率
  5. 自动部署：测试通过后自动部署到环境
avatar
文章
阅读
粉丝