E# 语言完整概述

E# 是一种语法类似C#的低级汇编语言，设计用于系统编程和底层开发。它结合了C#的高级语法糖和x86/x64汇编的底层控制能力，同时提供完整的内存安全保护。

🌟 主要特点

简洁语法：类似C#的高级语法，易于学习
底层控制：支持x86/x64汇编指令和内联汇编
内存安全：边界检查、空指针保护、自动内存管理
跨平台：支持Linux、Windows、未来支持ARM64
丰富标准库：内存管理、字符串操作、文件IO
现代特性：泛型、Lambda、异常处理、并发

🏗️ 语言架构

E# 提供两种编程模式：

高级模式：类似C#的面向对象编程
低级模式：直接汇编编程，系统级开发

🚀 第一个程序

高级C#风格

namespace HelloWorld;

class Program
{
    void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

低级汇编风格

section .data
    msg: db "Hello from E#!", 0xA
    len: equ $ - msg

section .text
    global _start

function void _start() asm {
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, msg        ; 消息地址
    mov rdx, len        ; 消息长度
    syscall
    
    mov rax, 60         ; sys_exit
    xor rdi, rdi        ; 状态码0
    syscall
}

命名空间

命名空间用于组织代码，每个E#程序都必须有命名空间。

基本语法

namespace 程序名称;

// 代码内容

嵌套命名空间

namespace MyApp.Utils {
    class StringHelper {
        // 实现...
    }
}

类定义

类是E#程序的基本组织单位，支持继承、多态等面向对象特性。

基本类定义

class Calculator {
    private int result;
    
    public Calculator() {
        result = 0;
    }
    
    public int add(int a, int b) {
        result = a + b;
        return result;
    }
}

继承示例

class Animal {
    protected string name;
    
    public Animal(string n) {
        name = n;
    }
    
    virtual public void speak() {
        Console.WriteLine(name + " makes a sound");
    }
}

class Dog extends Animal {
    public Dog(string n) : Animal(n) {}
    
    override public void speak() {
        Console.WriteLine(name + " barks");
    }
}

主方法

主方法是程序的入口点，程序从这里开始执行。

高级模式主方法

class Program {
    void Main() {
        // 程序入口点
        Console.WriteLine("程序开始执行");
    }
}

低级模式入口点

section .text
    global _start

function void _start() asm {
    // 程序入口点
    // 系统调用等底层操作
}

段定义

在低级模式中，使用段来组织程序的不同部分。

标准段

section .data
    // 初始化的数据
    message: db "Hello", 0
    counter: dd 0

section .bss
    // 未初始化的数据
    buffer: resb 1024

section .text
    global _start
    // 代码段

基本数据类型

E# 支持丰富的数据类型，从8位到64位，有符号和无符号。

整数类型

类型	描述	大小	范围
`int8`	8位有符号整数	1字节	-128 到 127
`int16`	16位有符号整数	2字节	-32,768 到 32,767
`int32`	32位有符号整数	4字节	-2.1e9 到 2.1e9
`int64`	64位有符号整数	8字节	-9.2e18 到 9.2e18
`uint8`	8位无符号整数	1字节	0 到 255
`uint16`	16位无符号整数	2字节	0 到 65,535
`uint32`	32位无符号整数	4字节	0 到 4.2e9
`uint64`	64位无符号整数	8字节	0 到 1.8e19

浮点类型

类型	描述	大小	精度
`float32`	32位浮点数	4字节	~7位十进制
`float64`	64位浮点数	8字节	~15位十进制

高级数据类型

指针类型

int32* ptr;           // 指向int32的指针
int32** double_ptr; // 双重指针
void* generic_ptr;    // 通用指针

数组类型

int32 numbers[10];    // 固定大小数组
int32 dynamic[];     // 动态数组
int32 matrix[3][3];  // 多维数组

字符串类型

E# 提供安全且功能丰富的字符串操作。

字符串声明

string greeting = "Hello, E#!";
string empty = "";
string path = "C:\\Program Files\\E#";

字符串操作

string name = "World";
string message = "Hello, " + name;
int length = message.length();
string upper = message.to_upper();
bool contains = message.contains("Hello");

布尔类型

布尔类型用于逻辑判断，只有true和false两个值。

基本用法

bool isActive = true;
bool isCompleted = false;
bool result = (5 > 3);  // true

指针类型

指针提供直接的内存访问能力，E#提供安全的指针操作。

安全指针使用

int32* ptr = new int32(42);
if (!ptr.is_null()) {
    int32 value = *ptr;
    *ptr = 100;
}
delete ptr;

智能指针

unique_ptr smart_ptr = make_unique(42);
shared_ptr shared_str = make_shared("Hello");

整数变量

整数变量用于存储整数值，支持各种位宽。

整数变量声明

int32 age = 25;
uint64 big_number = 9223372036854775807;
int8 small = -128;
uint16 medium = 65535;

不同进制表示

int32 decimal = 42;
int32 hex = 0x2A;
int32 binary = 0b101010;
int32 octal = 0o52;

字符串变量

字符串变量用于存储文本数据。

字符串变量声明

string name = "张三";
string message = "欢迎使用E#";
string empty = "";
string unicode = "你好 🌍";

字符串格式化

int32 age = 25;
string info = "姓名：张三，年龄：" + age;
string formatted = string.format("姓名：{0}，年龄：{1}", "张三", age);

浮点变量

浮点变量用于存储小数和实数。

浮点变量声明

float32 pi = 3.14159f;
float64 precise = 3.141592653589793;
float32 temperature = -273.15f;
float64 price = 99.99;

布尔变量

布尔变量用于逻辑判断。

布尔变量声明

bool is_valid = true;
bool is_empty = false;
bool is_greater = (10 > 5);  // true

指针变量

指针变量存储内存地址。

指针变量声明

int32* ptr = new int32(42);
uint64* big_ptr = new uint64(1000000);
void* generic = nullptr;

基本函数定义

函数是代码重用的基本单位。

标准函数

function int add(int a, int b) {
    return a + b;
}

function void greet(string name) {
    Console.WriteLine("Hello, " + name);
}

汇编函数定义

汇编函数直接生成机器码，提供最大性能。

汇编函数

function int multiply(int a, int b) asm {
    mov eax, [a]
    imul eax, [b]
    ret
}

模板函数

模板函数支持泛型编程。

泛型函数

template
function T max(T a, T b) {
    return (a > b) ? a : b;
}

// 使用
int result = max(10, 20);  // 20
double dresult = max(3.14, 2.71);  // 3.14

Lambda表达式

Lambda表达式提供简洁的函数定义方式。

Lambda定义

auto add = (int x, int y) -> int { return x + y; };
auto is_even = (int x) -> bool { return x % 2 == 0; };

// 使用
int sum = add(5, 3);  // 8
bool check = is_even(4);  // true

Console.WriteLine

输出文本并换行。

基本用法

Console.WriteLine("Hello, World!");
Console.WriteLine("当前数字: " + count);
Console.WriteLine("姓名: " + name);
Console.WriteLine("结果: {0}", result);

Console.Write

输出文本但不换行。

基本用法

Console.Write("请输入: ");
Console.Write("进度: " + percent + "%");
Console.Write("处理中");
Console.Write(".");

格式化输出

支持复杂的格式化输出。

格式化字符串

int age = 25;
double score = 95.5;
string name = "张三";

Console.WriteLine("姓名: {0}, 年龄: {1}, 分数: {2:F2}", name, age, score);
Console.WriteLine("十六进制: {0:X}", 255);  // FF
Console.WriteLine("货币: {0:C}", 1234.56);  // ¥1,234.56

for循环

用于重复执行代码块。

基本for循环

// 基本for循环
for (int i = 0; i < 10; i++) {
    Console.WriteLine("数字: " + i);
}

// 倒序循环
for (int i = 10; i > 0; i--) {
    Console.WriteLine("倒计时: " + i);
}

// 遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    Console.WriteLine(numbers[i]);
}

while循环

条件为真时重复执行。

基本while循环

int count = 0;
while (count < 5) {
    Console.WriteLine("计数: " + count);
    count++;
}

// 无限循环
while (true) {
    string input = Console.ReadLine();
    if (input == "exit") break;
}

do-while循环

至少执行一次，然后检查条件。

基本do-while循环

int choice;
do {
    Console.WriteLine("请选择: 1.继续 2.退出");
    choice = int.parse(Console.ReadLine());
} while (choice != 2);

基本if语句

条件执行代码块。

基本if

int age = 18;
if (age >= 18) {
    Console.WriteLine("成年人");
}

if-else语句

条件为假时执行else块。

if-else

int score = 85;
if (score >= 60) {
    Console.WriteLine("及格");
} else {
    Console.WriteLine("不及格");
}

多重条件语句

多个条件判断。

if-else if-else

int grade = 85;
if (grade >= 90) {
    Console.WriteLine("优秀");
} else if (grade >= 80) {
    Console.WriteLine("良好");
} else if (grade >= 70) {
    Console.WriteLine("中等");
} else if (grade >= 60) {
    Console.WriteLine("及格");
} else {
    Console.WriteLine("不及格");
}

内存安全概述

E# 提供多层内存安全保护，从编译时检查到运行时防护，确保程序不会出现内存泄漏、缓冲区溢出、悬垂指针等问题。

🛡️ 安全特性总览

边界检查数组访问：自动防止缓冲区溢出
空指针保护：运行时空指针检查
自动内存管理：智能指针和垃圾回收
内存泄漏防护：RAII和自动清理
悬垂指针防护：所有权系统和生命周期检查

边界检查

E# 自动进行数组边界检查，防止缓冲区溢出攻击。

安全数组访问

// 安全数组访问
int[] arr = new int[10];
int val = arr[5];        // 自动边界检查
// arr[15] = 42;         // 运行时抛出 IndexOutOfBoundsException

// 安全边界检查
function int safe_get(int[] array, int index) {
    if (index < 0 || index >= array.length) {
        throw IndexOutOfBoundsException("数组索引越界");
    }
    return array[index];
}

安全容器

// 使用安全容器
safe_array numbers = safe_array(100);
numbers.add(42);
int value = numbers.get(0);  // 自动边界检查

safe_string text = "Hello World";
char c = text[5];  // 安全访问，不会溢出

空指针保护

E# 提供运行时空指针检查，防止空指针异常。

空安全操作符

// 空安全操作符
string str = get_string();
int len = str?.length() ?? 0;  // 空安全操作符

// 强制非空类型
string! non_null = "hello";    // 编译时保证非空
string? nullable = null;       // 可为空类型

智能指针空检查

unique_ptr ptr = make_unique(42);
if (!ptr.is_null()) {
    int value = *ptr;
    Console.WriteLine("值: " + value);
}

// 自动空指针检查
// *nullptr;  // 抛出 NullPointerException

自动内存管理

E# 结合智能指针、垃圾回收和RAII模式，实现自动内存管理。

智能指针

// 唯一所有权
unique_ptr unique = make_unique(42);
shared_ptr shared = make_shared("Hello");

// 自动垃圾回收
auto ptr = gc_new int[1000];  // 自动回收
auto obj = gc_new MyClass();   // 自动析构

内存池管理

// 内存池管理
MemoryPool pool(1024 * 1024);  // 1MB内存池
auto data = pool.allocate(100);
// 自动回收，无需手动释放

// RAII模式
class Resource {
    ~Resource() {  // 自动析构函数
        cleanup();
    }
};

内存泄漏防护

E# 提供多种机制防止内存泄漏。

泄漏检测

// 内存调试器
MemoryDebugger::enable();
int* ptr = new int[100];
// 如果ptr在作用域结束时未释放，报告泄漏

// 内存追踪
memory_tracker {
    auto buffer = new int[1000];
    // 自动检测泄漏
}

// 实时统计
MemoryStats stats = Memory::get_stats();
Console.WriteLine("活跃分配: " + stats.active_allocations);

对象池

// 对象池自动管理
ObjectPool object_pool;
auto obj = object_pool.acquire();
// 自动归还到对象池，防止泄漏

数组和集合

E# 提供丰富的数组和集合操作功能。

数组声明和初始化

// 数组声明和初始化
int numbers[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
string names[] = {"Alice", "Bob", "Charlie"};
float matrix[3][3] = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};

// 动态数组
int* dynamic_array = new int[100];
delete[] dynamic_array;

高级集合操作

// 安全数组操作
safe_array arr = safe_array();
arr.add(1);
arr.add(2);
arr.add(3);

int size = arr.size();
int sum = arr.sum();
arr.sort();
int index = arr.find(42);

// 列表和字典
List list = new List();
Dictionary dict = new Dictionary();
dict["key"] = 42;

结构体和类

E# 支持结构体和类的定义，支持面向对象编程。

结构体定义

// 结构体定义
struct Point3D {
    float x, y, z;
    
    function float distance_to(Point3D other) {
        float dx = x - other.x;
        float dy = y - other.y;
        float dz = z - other.z;
        return sqrt(dx*dx + dy*dy + dz*dz);
    }
};

// 使用
Point3D p1 = {1.0, 2.0, 3.0};
Point3D p2 = {4.0, 5.0, 6.0};
float distance = p1.distance_to(p2);

泛型和模板

支持泛型编程，编写可重用的代码。

泛型类

// 泛型类
class List {
    private T* data;
    private int size;
    private int capacity;
    
    public List() {
        capacity = 10;
        size = 0;
        data = new T[capacity];
    }
    
    public void add(T item) {
        if (size >= capacity) {
            resize();
        }
        data[size++] = item;
    }
    
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw IndexOutOfRangeException();
        }
        return data[index];
    }
};

// 使用
List int_list = new List();
List str_list = new List();

异常处理

E# 提供完整的异常处理机制。

异常处理语法

try {
    int* data = new int[1000000];
    if (data == null) {
        throw MemoryAllocationException("内存分配失败");
    }
    
    int result = divide(10, user_input);
    
} catch (DivisionByZeroException e) {
    Console.WriteLine("错误：除数不能为零");
    log_error(e.what());
} catch (MemoryAllocationException e) {
    Console.WriteLine("错误：内存不足");
    cleanup_resources();
} catch (...) {
    Console.WriteLine("未知错误发生");
} finally {
    cleanup();
}

并发支持

E# 支持多线程和并发编程。

线程创建

// 线程	hread worker = create_thread(function void() {
    for (int i = 0; i < 100; i++) {
        Console.WriteLine("工作中: " + i);
    }
});

// 互斥锁
mutex data_mutex;
int shared_data = 0;

function void safe_increment() {
    lock(data_mutex) {
        shared_data++;
    }
}

// 原子操作
atomic counter = 0;
function void increment_counter() {
    counter.fetch_add(1);
}

// 异步编程
async function int async_task() {
    await sleep(1000);
    return 42;
}

基本内联汇编

E# 支持内联汇编，提供底层硬件控制。

基本汇编块

asm {
    mov eax, 1
    add eax, ebx
    mov [result], eax
}

// 带参数的汇编
function int add_asm(int a, int b) asm {
    mov eax, [a]
    add eax, [b]
    ret
}

Volatile汇编

防止编译器优化的汇编代码。

Volatile汇编

asm volatile {
    cli  // 禁用中断
    hlt  // 停机
}

asm volatile {
    in al, dx    // IO端口读取
    out dx, al   // IO端口写入
}

汇编实例

实际汇编编程示例。

系统调用示例

// Linux系统调用 - 写入文件
function void write_file(string filename, string content) asm {
    mov rax, 2          // sys_open
    mov rdi, filename   // 文件名
    mov rsi, 1          // O_WRONLY
    mov rdx, 0o644      // 权限
    syscall
    
    mov r8, rax         // 保存文件描述符
    
    mov rax, 1          // sys_write
    mov rdi, r8         // 文件描述符
    mov rsi, content    // 内容
    mov rdx, length     // 长度
    syscall
    
    mov rax, 3          // sys_close
    mov rdi, r8
    syscall
}

Hello World示例

多种方式的Hello World程序。

高级C#风格

namespace HelloWorld;

class Program {
    void Main() {
        Console.WriteLine("Hello, World from E#!");
    }
}

Linux汇编风格

section .data
    msg: db "Hello from E# assembly!", 0xA
    len: equ $ - msg

section .text
    global _start

function void _start() asm {
    mov rax, 1          // sys_write
    mov rdi, 1          // stdout
    mov rsi, msg        // 消息
    mov rdx, len        // 长度
    syscall
    
    mov rax, 60         // sys_exit
    xor rdi, rdi        // 状态码0
    syscall
}

斐波那契示例

计算斐波那契数列的多种实现。

递归实现

function int fibonacci_recursive(int n) {
    if (n <= 1) return n;
    return fibonacci_recursive(n-1) + fibonacci_recursive(n-2);
}

迭代实现

function int fibonacci_iterative(int n) {
    if (n <= 1) return n;
    
    int a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        int temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

完整程序

namespace Fibonacci;

class Program {
    void Main() {
        Console.WriteLine("计算斐波那契数列");
        
        for (int i = 0; i <= 10; i++) {
            int result = fibonacci_iterative(i);
            Console.WriteLine("F(" + i + ") = " + result);
        }
    }
    
    function int fibonacci_iterative(int n) {
        if (n <= 1) return n;
        
        int a = 0, b = 1;
        for (int i = 2; i <= n; i++) {
            int temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }
}

内存安全示例

展示E#内存安全特性的实际应用。

安全数据处理

function void process_data() {
    try {
        safe_array numbers = safe_array();
        
        // 安全添加数据
        for (int i = 0; i < 100; i++) {
            numbers.add(i * 2);
        }
        
        // 安全访问
        for (uint64 i = 0; i < numbers.size(); i++) {
            int val = numbers.get(i);
            Console.WriteLine("值: " + val);
        }
        
        // 自动清理 - 无需手动释放
    } catch (MemoryException e) {
        Console.WriteLine("内存错误: " + e.message);
    }
}

系统调用示例

展示如何在E#中使用系统调用。

文件操作

// Linux系统调用 - 文件读写
namespace FileExample;

class FileManager {
    function void write_file(string filename, string content) {
        asm {
            // 系统调用实现文件写入
            // 这里会生成适当的汇编代码
        }
    }
    
    function string read_file(string filename) {
        asm {
            // 系统调用实现文件读取
            // 返回文件内容
        }
    }
}

标准库 - 内存管理

E# 标准库提供的内存管理功能。

内存管理函数

// 内存分配
function ptr malloc(uint64 size);
function void free(ptr p);
function ptr memset(ptr dest, int value, uint64 size);
function ptr memcpy(ptr dest, const ptr src, uint64 size);

// 内存信息
function uint64 get_total_memory();
function uint64 get_free_memory();
function MemoryStats get_memory_stats();

标准库 - 字符串操作

字符串处理的标准库函数。

字符串操作函数

// 基本操作
function uint64 strlen(string s);
function int strcmp(string s1, string s2);
function void strcpy(string dest, string src);
function string strcat(string dest, string src);

// 高级操作
function string substring(string s, int start, int length);
function int find(string haystack, string needle);
function string replace(string s, string old, string new);
function string to_upper(string s);
function string to_lower(string s);

标准库 - 输入输出

标准输入输出函数。

IO函数

// 基本IO
function void print(string msg);
function string read_line();
function int read_int();
function double read_double();

// 文件IO
class File {
    static function File open(string filename, string mode);
    function void write(string content);
    function string read_all();
    function void close();
};

E# 完整文档导航

E# 语言完整概述

🌟 主要特点

🏗️ 语言架构

🚀 第一个程序

高级C#风格

低级汇编风格

命名空间

基本语法

嵌套命名空间

类定义

基本类定义

继承示例

主方法

高级模式主方法

低级模式入口点

段定义

标准段

基本数据类型

整数类型

浮点类型

高级数据类型

指针类型

数组类型

字符串类型

字符串声明

字符串操作

布尔类型

基本用法

指针类型

安全指针使用

智能指针

整数变量

整数变量声明

不同进制表示

字符串变量

字符串变量声明

字符串格式化

浮点变量

浮点变量声明

布尔变量

布尔变量声明

指针变量

指针变量声明

基本函数定义

标准函数

汇编函数定义

汇编函数

模板函数

泛型函数

Lambda表达式

Lambda定义

Console.WriteLine

基本用法

Console.Write

基本用法

格式化输出

格式化字符串

for循环

基本for循环

while循环

基本while循环

do-while循环

基本do-while循环

基本if语句

基本if

if-else语句

if-else

多重条件语句

if-else if-else

内存安全概述

🛡️ 安全特性总览

边界检查

安全数组访问

安全容器

空指针保护

空安全操作符

智能指针空检查

自动内存管理

智能指针