本文将带你从C++基础回顾到面向对象编程,再到高级语法入门,最后通过一个简单的计算器项目实战来巩固所学知识,涵盖变量、控制结构、函数、类、模板、引用、指针以及异常处理等知识点,全面解析和实践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;
}
C++高级语法入门
模板与泛型编程
模板是一种允许创建可重用代码的技术,可以用于创建泛型类和函数,使得代码更加通用和灵活。
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;
}
项目实战:创建一个简单的计算器
需求分析
本项目的目标是创建一个简单的命令行计算器,支持加法、减法、乘法和除法运算。
功能设计
- 用户可以通过命令行输入两个数字和一个运算符。
- 计算器根据输入的运算符执行相应的运算。
- 输出运算结果。
- 提供退出功能。
代码实现
首先,定义一些基本的函数来执行加法、减法、乘法和除法运算。
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;
}
测试与调试
在完成代码后,可以通过以下步骤进行测试和调试:
- 运行程序并输入不同的数字和运算符,检查输出结果是否正确。
- 测试除法时输入0,检查是否能正确处理除以0的情况。
- 测试无效的运算符,检查是否能正确处理。
常见问题与解决方法
常见编译错误
编译错误通常会指出代码中的错误,如语法错误、类型不匹配等。
// 错误示例:缺少分号
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++的基础知识和高级语法,并能够编写出功能完善的应用程序。