本文将带你从C++基础回顾到面向对象编程，再到高级语法入门，最后通过一个简单的计算器项目实战来巩固所学知识，涵盖变量、控制结构、函数、类、模板、引用、指针以及异常处理等知识点，全面解析和实践C++高级语法项目实战。

变量与数据类型

C++中的变量是程序中用于存储数据的标识符，每个变量都有其特定的数据类型，数据类型定义了变量能够存储的数据种类和大小。C++提供了多种内置数据类型，包括整型、浮点型、字符型、布尔型和枚举等。

整型

整型主要用于存储整数，如int、short、long等。

int a = 123;
short b = 20;
long c = 1000000;

浮点型

浮点型用于存储具有小数部分的数字，如float和double。

float pi = 3.14;
double e = 2.71828;

字符型

字符型用于存储单个字符，如char。

char ch = 'a';

布尔型

布尔型用于存储逻辑值，如bool。

bool flag = true;

枚举

枚举用于定义一组命名的整数常量，如enum。

enum Color { RED, GREEN, BLUE };
Color color = RED;

数组

数组用于存储一组相同类型的元素，如int数组。

int numbers[5] = { 1, 2, 3, 4, 5 };

控制结构

C++中的控制结构用于控制程序的执行流程。常见的控制结构包括if、switch语句和各种类型的循环。

if语句

if语句允许程序根据某个条件的真假来执行不同的代码块。

int x = 10;
if (x > 5) {
    std::cout << "x is greater than 5" << std::endl;
} else {
    std::cout << "x is not greater than 5" << std::endl;
}

switch语句

switch语句根据变量的不同值执行不同的代码块。

int number = 2;
switch (number) {
    case 1:
        std::cout << "The number is 1" << std::endl;
        break;
    case 2:
        std::cout << "The number is 2" << std::endl;
        break;
    default:
        std::cout << "The number is not 1 or 2" << std::endl;
}

循环

循环结构允许代码块重复执行，直到满足某个条件为止。常见的循环结构包括for、while和do...while。

// 使用for循环
for (int i = 0; i < 5; i++) {
    std::cout << "Iteration " << i << std::endl;
}

// 使用while循环
int j = 0;
while (j < 5) {
    std::cout << "Iteration " << j << std::endl;
    j++;
}

// 使用do...while循环
int k = 0;
do {
    std::cout << "Iteration " << k << std::endl;
    k++;
} while (k < 5);

函数与参数传递

函数是程序的一部分，用于执行特定的任务，可以接收参数并返回结果。参数传递包括值传递、引用传递和指针传递。

值传递

值传递是将实参的值复制给形参。

void printValue(int x) {
    std::cout << "The value is " << x << std::endl;
}

int main() {
    int value = 42;
    printValue(value);
    return 0;
}

引用传递

引用传递是将实参的地址传递给形参，形参是对实参的别名。

void printValue(int &x) {
    x += 10;
    std::cout << "The value is " << x << std::endl;
}

int main() {
    int value = 42;
    printValue(value);
    std::cout << "The final value is " << value << std::endl;
    return 0;
}

指针传递

指针传递是将实参的地址传递给形参，形参是一个指向实参的指针。

void printValue(int *x) {
    *x += 10;
    std::cout << "The value is " << *x << std::endl;
}

int main() {
    int value = 42;
    printValue(&value);
    std::cout << "The final value is " << value << std::endl;
    return 0;
}

类与对象

面向对象编程中，类是一种数据类型，用于定义具有特定属性和行为的对象。对象是类的实例。

class Person {
public:
    std::string name;
    int age;

    void introduce() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person person1;
    person1.name = "Alice";
    person1.age = 25;
    person1.introduce();

    return 0;
}

继承与多态

继承允许一个类（子类）继承另一个类（基类）的属性和方法，多态允许基类的指针或引用指向不同类型的对象，并根据对象的实际类型调用不同的方法。

class Animal {
public:
    virtual void makeSound() = 0; // 纯虚函数，表示抽象类
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    Animal *dog = new Dog();
    Animal *cat = new Cat();
    dog->makeSound();
    cat->makeSound();
    delete dog;
    delete cat;
    return 0;
}

封装与数据隐藏

封装是一种设计机制，用于将一个类的数据成员和方法封装在一起，外部代码无法直接访问这些数据成员，只能通过类提供的公共接口进行访问。

class BankAccount {
private:
    int balance;

public:
    BankAccount(int initialBalance) : balance(initialBalance) {}

    void deposit(int amount) {
        balance += amount;
    }

    int getBalance() {
        return balance;
    }

    void withdraw(int amount) {
        balance -= amount;
    }
};

int main() {
    BankAccount account(100);
    account.deposit(50);
    account.withdraw(25);
    std::cout << "Balance: " << account.getBalance() << std::endl;
    return 0;
}

模板与泛型编程

模板是一种允许创建可重用代码的技术，可以用于创建泛型类和函数，使得代码更加通用和灵活。

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result1 = add<int>(10, 20);
    double result2 = add<double>(3.5, 4.5);
    std::cout << "Sum of integers: " << result1 << std::endl;
    std::cout << "Sum of doubles: " << result2 << std::endl;
    return 0;
}

引用与指针

引用是变量的别名，指针是变量的地址。引用和指针都允许间接访问变量。

int main() {
    int val = 42;
    int& ref = val; // 引用的声明
    int *ptr = &val; // 指针的声明

    ref += 5; // 使用引用修改值
    *ptr += 5; // 使用指针修改值

    std::cout << "Value: " << val << std::endl;
    std::cout << "Value via reference: " << ref << std::endl;
    std::cout << "Value via pointer: " << *ptr << std::endl;

    return 0;
}

异常处理

异常处理允许程序在运行时检测和处理错误。通过使用try、catch和throw关键字，可以捕获和处理异常。

void divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Cannot divide by zero");
    }
    std::cout << "Result: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0);
    } catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    return 0;
}

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。

class Singleton {
private:
    static Singleton* instance;
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    void print() {
        std::cout << "Singleton instance" << std::endl;
    }
};

Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->print();
    return 0;
}

工厂模式

工厂模式提供了一种创建对象的方法，使得系统可以在运行时动态地实例化不同的对象。

class AbstractProduct {
public:
    virtual ~AbstractProduct() {}
    virtual void operation() const = 0;
};

class ConcreteProduct1 : public AbstractProduct {
public:
    void operation() const override {
        std::cout << "Product 1 operation" << std::endl;
    }
};

class ConcreteProduct2 : public AbstractProduct {
public:
    void operation() const override {
        std::cout << "Product 2 operation" << std::endl;
    }
};

class Factory {
public:
    AbstractProduct* createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return nullptr;
    }
};

int main() {
    Factory factory;
    AbstractProduct* product1 = factory.createProduct(1);
    AbstractProduct* product2 = factory.createProduct(2);
    product1->operation();
    product2->operation();
    delete product1;
    delete product2;
    return 0;
}

观察者模式

观察者模式允许一个对象（主题/发布者）在状态发生变化时通知其他对象（观察者）。

#include <iostream>
#include <list>

class Subject {
private:
    std::list<Observer*> observers;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void detach(Observer* observer) {
        observers.remove(observer);
    }

    void notify() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};

class Observer {
public:
    virtual void update() const = 0;
};

class ConcreteObserver : public Observer {
public:
    void update() const override {
        std::cout << "Observer updated" << std::endl;
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer;
    subject.attach(&observer);
    subject.notify();
    subject.detach(&observer);
    subject.notify();
    return 0;
}

需求分析

本项目的目标是创建一个简单的命令行计算器，支持加法、减法、乘法和除法运算。

功能设计

1. 用户可以通过命令行输入两个数字和一个运算符。
2. 计算器根据输入的运算符执行相应的运算。
3. 输出运算结果。
4. 提供退出功能。

代码实现

首先，定义一些基本的函数来执行加法、减法、乘法和除法运算。

double add(double a, double b) {
    return a + b;
}

double subtract(double a, double b) {
    return a - b;
}

double multiply(double a, double b) {
    return a * b;
}

double divide(double a, double b) {
    if (b == 0) {
        std::cout << "Cannot divide by zero" << std::endl;
        return 0;
    }
    return a / b;
}

接下来，编写一个主函数来处理用户输入并调用相应的运算函数。

#include <iostream>
#include <string>

double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);

int main() {
    double num1, num2, result;
    std::string operatorSymbol;

    std::cout << "Enter first number: ";
    std::cin >> num1;
    std::cout << "Enter operator (+, -, *, /): ";
    std::cin >> operatorSymbol;
    std::cout << "Enter second number: ";
    std::cin >> num2;

    if (operatorSymbol == "+") {
        result = add(num1, num2);
        std::cout << "Result: " << result << std::endl;
    } else if (operatorSymbol == "-") {
        result = subtract(num1, num2);
        std::cout << "Result: " << result << std::endl;
    } else if (operatorSymbol == "*") {
        result = multiply(num1, num2);
        std::cout << "Result: " << result << std::endl;
    } else if (operatorSymbol == "/") {
        result = divide(num1, num2);
        std::cout << "Result: " << result << std::endl;
    } else {
        std::cout << "Invalid operator" << std::endl;
    }

    return 0;
}

测试与调试

在完成代码后，可以通过以下步骤进行测试和调试：

1. 运行程序并输入不同的数字和运算符，检查输出结果是否正确。
2. 测试除法时输入0，检查是否能正确处理除以0的情况。
3. 测试无效的运算符，检查是否能正确处理。

常见问题与解决方法

常见编译错误

编译错误通常会指出代码中的错误，如语法错误、类型不匹配等。

// 错误示例：缺少分号
int a = 10
// 正确的代码
int a = 10;

运行时常见错误

运行时错误发生在程序执行过程中，如内存泄漏、运行时异常等。

// 错误示例：内存泄漏
int* ptr = new int[10];
// 正确的代码
int* ptr = new int[10];
delete[] ptr;

调试技巧

调试技巧包括使用断点、单步执行、查看变量值等。

// 使用断点和单步执行
int main() {
    int a = 10;
    int b = 20;
    int c = a + b;
    std::cout << "Result: " << c << std::endl;
    return 0;
}

通过以上步骤，你可以更好地理解和掌握C++的基础知识和高级语法，并能够编写出功能完善的应用程序。