C++11工程实践学习：从入门到初级应用教程

本文介绍了C++11语言的基础知识，包括数据类型、常量、运算符、函数和控制结构等。文章还深入讲解了面向对象编程、标准模板库（STL）的应用，以及文件操作与异常处理。此外，通过一个简单的计算器项目实践，详细展示了C++11工程实践学习的过程。

在C++中，数据类型决定了变量可以存储的数据类型。C++支持多种基本数据类型，包括整型、浮点型、字符型等。每种数据类型都有其特定的取值范围和存储大小。变量是用于存储数据的标识符。

基本数据类型

• int：整型，用于存储整数值，如123、-123等。
• float：单精度浮点型，用于存储单精度浮点数，如3.14、-0.1等。
• double：双精度浮点型，用于存储双精度浮点数，如3.14159、-0.001等。
• char：字符型，用于存储单个字符，如'a'、'b'等。
• bool：布尔型，用于存储布尔值，即true和false。

示例代码

#include <iostream>

int main() {
    int age = 25;          // 整型变量
    float height = 1.75;   // 单精度浮点型变量
    double weight = 68.5;  // 双精度浮点型变量
    char grade = 'A';      // 字符型变量
    bool isAdult = true;   // 布尔型变量

    std::cout << "Age: " << age << "\n";
    std::cout << "Height: " << height << "\n";
    std::cout << "Weight: " << weight << "\n";
    std::cout << "Grade: " << grade << "\n";
    std::cout << "Is Adult: " << isAdult << "\n";

    return 0;
}

在C++中，常量是指值在程序运行过程中不可更改的量。常量可以分为字面量和命名常量。

字面量

• 整型字面量：如123、-123
• 浮点型字面量：如3.14、-0.1
• 字符型字面量：如'a'、'b'
• 字符串字面量：如"hello"、"world"
• 布尔型字面量：如true、false

命名常量

可以通过const关键字定义命名常量。

示例代码

#include <iostream>

int main() {
    const int MAX_VALUE = 100;  // 命名常量
    const float PI = 3.14159;   // 命名常量

    std::cout << "Max Value: " << MAX_VALUE << "\n";
    std::cout << "PI: " << PI << "\n";

    return 0;
}

C++支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符等。

算术运算符

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取余

逻辑运算符

• &&：逻辑与
• ||：逻辑或
• !：逻辑非

示例代码

#include <iostream>

int main() {
    int a = 10;
    int b = 5;

    std::cout << "a + b: " << (a + b) << "\n";
    std::cout << "a - b: " << (a - b) << "\n";
    std::cout << "a * b: " << (a * b) << "\n";
    std::cout << "a / b: " << (a / b) << "\n";
    std::cout << "a % b: " << (a % b) << "\n";

    bool result1 = (a > b) && (a < 20);
    bool result2 = (a > b) || (b > a);
    bool result3 = !(a > b);

    std::cout << "Result1: " << result1 << "\n";
    std::cout << "Result2: " << result2 << "\n";
    std::cout << "Result3: " << result3 << "\n";

    return 0;
}

函数是组织代码的模块，用于完成特定任务。函数由函数声明和函数定义组成。函数定义包括函数头和函数体。

函数声明

返回类型 函数名(参数列表);

函数定义

返回类型 函数名(参数列表) {
    函数体
}

示例代码

#include <iostream>

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

int main() {
    int result = add(5, 3);
    std::cout << "Addition Result: " << result << "\n";

    return 0;
}

控制结构用于控制程序的执行流程，常见的控制结构包括if、switch、for、while等。

if 语句

if (条件) {
    语句1;
} else {
    语句2;
}

switch 语句

switch (表达式) {
    case 常量1:
        语句1;
        break;
    case 常量2:
        语句2;
        break;
    default:
        语句3;
}

for 循环

for (初始化; 条件; 更新) {
    语句;
}

while 循环

while (条件) {
    语句;
}

示例代码

#include <iostream>

int main() {
    int num = 10;

    if (num > 0) {
        std::cout << "Positive number\n";
    } else {
        std::cout << "Non-positive number\n";
    }

    switch (num % 2) {
        case 0:
            std::cout << "Even number\n";
            break;
        case 1:
            std::cout << "Odd number\n";
            break;
    }

    for (int i = 0; i < 5; i++) {
        std::cout << "Iteration: " << i << "\n";
    }

    int count = 0;
    while (count < 5) {
        std::cout << "Count: " << count << "\n";
        count++;
    }

    return 0;
}

在面向对象编程中，类是对象的模板，对象是类的实例。类定义了对象的数据和行为（方法）。

类的定义

class 类名 {
public:
    // 公共成员变量和函数
private:
    // 私有成员变量和函数
};

对象的创建

类名 对象名;

示例代码

#include <iostream>

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

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

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

    person.introduce();

    return 0;
}

类中的成员函数用于定义对象的行为，成员变量用于存储对象的数据。

成员函数

成员函数可以是公共的（可被对象外部访问）或私有的（仅在类内部访问）。

成员变量

成员变量可以是公共的或私有的，私有成员变量通常通过公共成员函数访问。

示例代码

#include <iostream>

class Rectangle {
private:
    int width;
    int height;

public:
    void setDimensions(int w, int h) {
        width = w;
        height = h;
    }

    int getArea() {
        return width * height;
    }
};

int main() {
    Rectangle rect;
    rect.setDimensions(5, 4);

    std::cout << "Area: " << rect.getArea() << "\n";

    return 0;
}

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。多态是指通过子类可以调用父类方法的不同实现形式。

继承

class Base {
public:
    void method() {
        std::cout << "Base method\n";
    }
};

class Derived : public Base {
public:
    void method() override {
        std::cout << "Derived method\n";
    }
};

int main() {
    Base base;
    Derived derived;

    base.method(); // 输出 "Base method"
    derived.method(); // 输出 "Derived method"

    Base* basePtr = &derived;
    basePtr->method(); // 输出 "Derived method"，展示多态性

    return 0;
}

STL提供了多种容器，如vector、list、map等，用于存储和管理数据。

vector

vector是一个动态数组，可以方便地进行插入和删除操作。

list

list是一个双向链表，支持高效的插入和删除操作。

map

map是一个关联容器，存储键值对。

示例代码

#include <iostream>
#include <vector>
#include <list>
#include <map>

int main() {
    // 使用vector
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 使用list
    std::list<int> lst = {1, 2, 3, 4, 5};
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 使用map
    std::map<int, std::string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}

迭代器用于遍历容器，算法用于对容器中的数据进行操作。

迭代器

迭代器类似于指针，可以指向容器中的元素。

常用算法

• sort：排序
• find：查找
• count：计数
• reverse：反转

示例代码

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 3, 8, 1, 2};

    // 使用sort
    std::sort(vec.begin(), vec.end());
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    // 使用find
    auto it = std::find(vec.begin(), vec.end(), 2);
    if (it != vec.end()) {
        std::cout << "Found value: " << *it << "\n";
    }

    // 使用count
    int count = std::count(vec.begin(), vec.end(), 2);
    std::cout << "Count of 2: " << count << "\n";

    // 使用reverse
    std::reverse(vec.begin(), vec.end());
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << "\n";

    return 0;
}

文件操作用于读取和写入文件。C++提供了多种文件操作函数，如ifstream、ofstream、fstream等。

文件打开与关闭

std::ifstream file("file.txt");
file.close();

文件读写

file >> content;
file << content;

示例代码

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("output.txt");
    file << "Hello, World!";
    file.close();

    std::ifstream file("output.txt");
    std::string content;
    while (file >> content) {
        std::cout << "File Content: " << content << "\n";
    }

    file.open("output.txt", std::ios::app);
    file << " More text.";
    file.close();

    file.open("output.txt", std::ios::in);
    while (file >> content) {
        std::cout << "File Content: " << content << "\n";
    }

    return 0;
}

异常处理是程序中处理错误和异常情况的一种机制。C++提供了try、catch等关键字进行异常处理。

异常捕获

try {
    // 可能抛出异常的代码
} catch (异常类型1) {
    // 处理异常类型1
} catch (异常类型2) {
    // 处理异常类型2
}

示例代码

#include <iostream>
#include <exception>

void function() {
    throw std::runtime_error("Runtime error occurred.");
}

int main() {
    try {
        function();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught runtime error: " << e.what() << "\n";
    }

    return 0;
}

开发一个简单的计算器应用，实现加、减、乘、除等基本运算。开发流程包括需求分析、设计、编码、测试等阶段。

需求分析

确定计算器的基本功能，如加法、减法、乘法、除法。

设计

设计类和函数，定义好接口和实现。

编码

编写源代码，实现计算器功能。

测试

测试程序的功能，确保符合预期。

示例代码

#include <iostream>

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

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

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

    int divide(int a, int b) {
        if (b == 0) {
            std::cerr << "Error: Division by zero\n";
            return 0;
        }
        return a / b;
    }
};

int main() {
    Calculator calc;

    std::cout << "Addition: " << calc.add(5, 3) << "\n";
    std::cout << "Subtraction: " << calc.subtract(5, 3) << "\n";
    std::cout << "Multiplication: " << calc.multiply(5, 3) << "\n";
    std::cout << "Division: " << calc.divide(5, 3) << "\n";

    return 0;
}

调试和测试是确保代码质量和功能的重要步骤。调试用于找出并修复程序中的错误，测试用于验证程序的功能。

调试

使用调试工具，如GDB，逐步执行程序并检查变量的值。

测试

编写单元测试，确保每个函数的功能正确。

示例代码

#include <gtest/gtest.h>

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

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

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

    int divide(int a, int b) {
        if (b == 0) {
            std::cerr << "Error: Division by zero\n";
            return 0;
        }
        return a / b;
    }
};

TEST(CalculatorTest, Add) {
    Calculator calc;
    EXPECT_EQ(calc.add(5, 3), 8);
}

TEST(CalculatorTest, Subtract) {
    Calculator calc;
    EXPECT_EQ(calc.subtract(5, 3), 2);
}

TEST(CalculatorTest, Multiply) {
    Calculator calc;
    EXPECT_EQ(calc.multiply(5, 3), 15);
}

TEST(CalculatorTest, Divide) {
    Calculator calc;
    EXPECT_EQ(calc.divide(5, 3), 1);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

通过以上内容，你将能够掌握C++11的基础知识，并能够进行简单的工程实践。更多详细信息和示例代码可以在M慕课网上找到，那里提供了许多适合初学者的教程和项目。