C++开发入门教程：从零开始学习C++

本文详细介绍了C++开发环境的搭建方法，包括选择合适的编译器和IDE，以及在Windows、Linux和MacOS下的安装步骤。通过示例代码，我们了解了如何编写和运行第一个C++程序，并深入学习了C++的基础语法、流程控制、函数与数组的应用以及面向对象编程的基本概念。

选择合适的编译器和IDE

在开始学习C++之前，首先需要搭建一个合适的开发环境。开发环境包括编译器和集成开发环境（IDE）。编译器负责将源代码编译成机器语言，而IDE则提供了一套完整的开发工具，包括代码编辑器、调试器、版本控制工具等。

对于初学者，推荐使用以下工具：

• 编译器：GCC（GNU Compiler Collection）是开源的、功能强大的编译器，支持多种编程语言，包括C++。
• IDE：Visual Studio Code（VS Code）是一个流行的代码编辑器，支持多种编程语言和插件扩展。Code::Blocks、Eclipse CDT也是不错的选择，它们专为C++开发设计。

Windows下的安装步骤

1. 安装编译器：

   • 下载并安装MinGW（Minimalist GNU for Windows），它包含了GCC编译器及其他工具。
   • 访问MinGW的官方网站，并按照安装向导进行操作。
   • 安装过程中，确保选择安装mingw64-base和mingw64-gcc-g++包。
2. 安装IDE：
   • 访问VS Code的官方网站，下载并安装VS Code。
   • 在VS Code中安装C++扩展，如C++扩展包。
   • 安装C++插件后，选择Extensions菜单，搜索C++，然后安装推荐的扩展。

Linux下的安装步骤

1. 安装编译器：

   • 打开终端，输入以下命令安装GCC和G++：

     sudo apt-get update
     sudo apt-get install g++

2. 安装IDE：
   • 在Ubuntu中，可以通过以下命令安装VS Code：

     sudo snap install --classic code

   • 安装完成后，可以通过VS Code安装C++扩展，具体步骤同Windows。

MacOS下的安装步骤

1. 安装编译器：

   • 在MacOS中，可以通过Homebrew包管理器安装GCC：

     /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/main/install.sh)"
     brew install gcc

2. 安装IDE：
   • 访问VS Code的官方网站，下载并安装VS Code。
   • 在VS Code中安装C++扩展，如C++扩展包。
   • 安装C++插件后，选择Extensions菜单，搜索C++，然后安装推荐的扩展。

第一个C++程序示例

接下来，我们编写一个简单的“Hello, World!”程序，这是每个编程语言学习的起点。

1. 创建第一个C++程序：

   • 打开VS Code或其他IDE，创建一个新的文件，命名为hello.cpp。

   • 输入以下代码：

     #include <iostream>
     
     int main() {
      std::cout << "Hello, World!" << std::endl;
      return 0;
     }

   • 这段代码包含了输入输出流库<iostream>，使用std::cout输出信息到控制台，并使用std::endl插入一个换行符。
   • main函数是程序的入口点，它返回0表示程序成功执行。
2. 编译和运行程序：
   • 打开终端，切换到包含hello.cpp文件的目录。
   • 编译代码：

     g++ hello.cpp -o hello

   • 运行程序：

     ./hello

你应该看到输出：

Hello, World!

总结

本节介绍了C++环境的搭建方法，包括选择合适的编译器和IDE，以及在Windows、Linux和MacOS下的安装步骤。通过一个简单的“Hello, World!”程序，我们初步了解了C++的基本结构和运行方式。接下来，我们将深入学习C++的基础语法。

数据类型和变量

在C++中，变量用于存储数据。每种变量都有特定的数据类型，该类型定义了变量可以存储的数据类型以及其在内存中的存储方式。C++提供了多种内置数据类型，包括整型、浮点型、字符型和布尔型等。

整型

整型用于存储整数。常见的整型数据类型包括int、short、long和long long等。以下是它们的定义和示例：

#include <iostream>

int main() {
    int a = 10;      // int 类型，通常为4字节
    short b = 5;     // short 类型，通常为2字节
    long c = 1000;   // long 类型，通常为4字节或8字节
    long long d = 9999999999999; // long long 类型，通常为8字节

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << ", d: " << d << std::endl;

    return 0;
}

浮点型

浮点型用于存储小数。常见的浮点型数据类型包括float和double。float通常为4字节，double通常为8字节。

#include <iostream>

int main() {
    float f = 3.14f; // float 类型
    double d = 3.14; // double 类型

    std::cout << "f: " << f << ", d: " << d << std::endl;

    return 0;
}

字符型

字符型用于存储单个字符。常用的字符型数据类型是char，它是一个包含单个字符的变量。字符可以使用单引号包围，如'a'。

#include <iostream>

int main() {
    char ch = 'A'; // char 类型
    std::cout << "ch: " << ch << std::endl;

    return 0;
}

布尔型

布尔型用于存储逻辑值，即true或false。布尔型数据类型是bool。

#include <iostream>

int main() {
    bool flag = true; // bool 类型
    std::cout << "flag: " << flag << std::endl;

    return 0;
}

变量的作用域和生命周期

变量的作用域是指变量在程序中可见的范围。变量的生命周期是指变量从创建到销毁的时间段。

局部变量

局部变量是在函数或代码块内部声明的变量。它们只能在其作用域内被访问，一旦超出作用域，局部变量将被销毁。

#include <iostream>

void example() {
    int localVar = 20; // 局部变量
    std::cout << "localVar: " << localVar << std::endl;
}

int main() {
    example();
    // std::cout << "localVar: " << localVar << std::endl; // 这行会导致编译错误，localVar不在 main 的作用域内
    return 0;
}

全局变量

全局变量是在函数外部声明的变量。它们在整个程序中可见，可以在任何函数中访问。

#include <iostream>

int globalVar = 10; // 全局变量

void example() {
    int localVar = 20; // 局部变量
    std::cout << "Inside example, localVar: " << localVar << std::endl;
    std::cout << "Inside example, globalVar: " << globalVar << std::endl;
    globalVar = 30;
}

int main() {
    example();
    std::cout << "After example, globalVar: " << globalVar << std::endl;
    // std::cout << "After example, localVar: " << localVar << std::endl; // 这行会导致编译错误，localVar不在 main 的作用域内
    return 0;
}

常用运算符及其优先级

C++提供了多种运算符，包括算术运算符、关系运算符、逻辑运算符等。运算符的优先级决定了表达式中运算符的执行顺序。

算术运算符

算术运算符用于执行基本的数学运算，如加法、减法、乘法、除法和取模。

#include <iostream>

int main() {
    int a = 10, b = 5;
    std::cout << "a + b: " << (a + b) << std::endl;
    std::cout << "a - b: " << (a - b) << std::endl;
    std::cout << "a * b: " << (a * b) << std::endl;
    std::cout << "a / b: " << (a / b) << std::endl;
    std::cout << "a % b: " << (a % b) << std::endl;

    return 0;
}

关系运算符

关系运算符用于比较两个值，返回布尔值（true或false）。

#include <iostream>

int main() {
    int a = 10, b = 5;
    std::cout << "a == b: " << (a == b) << std::endl;
    std::cout << "a != b: " << (a != b) << std::endl;
    std::cout << "a > b: " << (a > b) << std::endl;
    std::cout << "a < b: " << (a < b) << std::endl;
    std::cout << "a >= b: " << (a >= b) << std::endl;
    std::cout << "a <= b: " << (a <= b) << std::endl;

    return 0;
}

逻辑运算符

逻辑运算符用于组合多个布尔表达式，返回布尔值。

#include <iostream>

int main() {
    bool a = true, b = false;
    std::cout << "a && b: " << (a && b) << std::endl;
    std::cout << "a || b: " << (a || b) << std::endl;
    std::cout << "!a: " << (!a) << std::endl;

    return 0;
}

总结

本节介绍了C++中基本的数据类型和变量，包括整型、浮点型、字符型和布尔型。我们还讨论了变量的作用域和生命周期，以及常用的运算符及其优先级。通过这些基本概念的学习，你将能够编写更复杂的C++程序。接下来，我们将深入了解流程控制结构。

if语句和switch语句

在C++中，流程控制语句用于控制程序的执行流程。if语句和switch语句是最常用的条件控制语句。

if语句

if语句用于基于条件执行代码块。条件为true时执行代码块，为false时不执行。

#include <iostream>

int main() {
    int a = 10;

    if (a > 5) {
        std::cout << "a is greater than 5" << std::endl;
    } else {
        std::cout << "a is less than or equal to 5" << std::endl;
    }

    return 0;
}

switch语句

switch语句用于基于变量的值执行多个分支中的一个。switch语句类似于一系列if语句的组合。

#include <iostream>

int main() {
    int a = 2;

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

    return 0;
}

for循环、while循环和do-while循环

循环语句用于重复执行一段代码。C++支持多种循环结构，包括for循环、while循环和do-while循环。

for循环

for循环用于执行一段代码多次，通常用于已知循环次数的情况。

#include <iostream>

int main() {
    for (int i = 0; i < 5; i++) {
        std::cout << "i: " << i << std::endl;
    }

    return 0;
}

while循环

while循环用于执行一段代码，直到条件变为false。通常用于未知循环次数的情况。

#include <iostream>

int main() {
    int i = 0;
    while (i < 5) {
        std::cout << "i: " << i << std::endl;
        i++;
    }

    return 0;
}

do-while循环

do-while循环与while循环类似，但它首先执行循环体，然后检查条件。即使条件一开始为false，循环体也会执行一次。

#include <iostream>

int main() {
    int i = 0;

    do {
        std::cout << "i: " << i << std::endl;
        i++;
    } while (i < 5);

    return 0;
}

跳转语句（break和continue）

跳转语句用于改变循环的执行流程。

break语句

break语句用于立即退出循环或switch语句。

#include <iostream>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            break;
        }
        std::cout << "i: " << i << std::endl;
    }

    return 0;
}

continue语句

continue语句用于跳过当前循环的剩余部分，直接进入下一次迭代。

#include <iostream>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        std::cout << "i: " << i << std::endl;
    }

    return 0;
}

总结

本节介绍了C++中的流程控制语句，包括if语句和switch语句，以及三种循环结构：for循环、while循环和do-while循环。我们还讨论了跳转语句break和continue。通过这些控制结构，你可以更灵活地控制程序的执行流程。接下来，我们将深入了解函数和数组的应用。

函数的定义与调用

函数是一种封装功能的代码块，可以独立调用和重复使用。函数定义包括函数名、返回类型、参数列表和函数体。

函数定义

函数定义的基本结构如下：

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

例如，定义一个返回int类型的函数，该函数接受两个int参数：

#include <iostream>

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

函数调用

在程序的其他部分，可以通过函数名调用函数，并传入相应的参数。

#include <iostream>

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

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

多参数函数调用

函数可以接受多个参数，例如：

#include <iostream>

int addThreeNumbers(int a, int b, int c) {
    return a + b + c;
}

int main() {
    int result = addThreeNumbers(1, 2, 3);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

函数的返回值与参数传递

函数可以通过返回类型指定返回值的类型，返回值是函数执行结果的一部分。

无返回值的函数

有时候，函数不需要返回任何值，可以使用void作为返回类型。

#include <iostream>

void printMessage() {
    std::cout << "Hello, world!" << std::endl;
}

int main() {
    printMessage();

    return 0;
}

参数传递

参数传递分为值传递和引用传递两种方式。

• 值传递：实参传递给形参的副本。
• 引用传递：实参直接传递给形参，形参是一个指向实参的引用。

#include <iostream>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

void swapRef(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swap(x, y);
    std::cout << "After swap (by value): x = " << x << ", y = " << y << std::endl;

    swapRef(x, y);
    std::cout << "After swap (by reference): x = " << x << ", y = " << y << std::endl;

    return 0;
}

一维数组、二维数组及其操作

数组是一种容器，用于存储一组相同类型的元素。数组可以通过索引访问和操作其元素。

一维数组

一维数组是一个线性序列，通过索引访问其元素。

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }

    return 0;
}

二维数组

二维数组是一个矩阵结构，通过两个索引访问其元素。

#include <iostream>

int main() {
    int arr[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << "arr[" << i << "][" << j << "] = " << arr[i][j] << std::endl;
        }
    }

    return 0;
}

总结

本节介绍了C++中函数的定义与调用，以及函数的返回值与参数传递。我们还讨论了数组的基本概念，包括一维数组和二维数组的操作。通过这些内容的学习，你将能够编写更复杂和功能丰富的C++程序。接下来，我们将深入了解类与对象的基本概念。

类的定义与对象的创建

在面向对象编程中，类是对象的模板，描述了对象的属性（成员变量）和行为（成员函数）。对象是类的具体实例。

类定义

类定义的基本结构如下：

class ClassName {
    private:
        // 私有成员变量
    public:
        // 公有成员函数
};

例如，定义一个Person类：

#include <iostream>

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

    public:
        // 构造函数
        Person(std::string n, int a) : name(n), age(a) {}

        // 成员函数
        void display() {
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        }
};

对象的创建

在程序的其他部分，可以通过类名创建对象，并调用类的成员函数。

#include <iostream>
#include "Person.h" // 假设Person类定义在Person.h头文件中

int main() {
    Person person("Alice", 25);
    person.display();

    return 0;
}

成员变量和成员函数

成员变量是类的内部状态，描述了对象的属性。成员函数是类的行为，描述了对象的操作。

成员变量

成员变量用于存储对象的数据。

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

    public:
        Person(std::string n, int a) : name(n), age(a) {}
        void display() {
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        }
};

成员函数

成员函数用于操作对象的数据。

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

    public:
        Person(std::string n, int a) : name(n), age(a) {}
        void display() {
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        }
};

构造函数与析构函数

构造函数用于初始化对象，析构函数用于释放对象资源。

构造函数

构造函数是一个特殊的成员函数，用于在创建对象时初始化对象的数据。

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

    public:
        Person(std::string n, int a) : name(n), age(a) {}
        void display() {
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        }
};

析构函数

析构函数是一个特殊的成员函数，用于在对象销毁时释放资源。

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

    public:
        Person(std::string n, int a) : name(n), age(a) {}
        ~Person() {
            std::cout << "Person destroyed" << std::endl;
        }
        void display() {
            std::cout << "Name: " << name << ", Age: " << age << std::endl;
        }
};

总结

本节介绍了C++中面向对象编程的基本概念，包括类的定义与对象的创建、成员变量和成员函数，以及构造函数和析构函数。通过这些内容的学习，你将能够编写更面向对象的C++程序。接下来，我们将深入学习面向对象编程的进阶概念。

继承与多态

继承是一种代码复用机制，允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。

继承示例

#include <iostream>

class Animal {
    public:
        void sound() {
            std::cout << "This is an animal sound." << std::endl;
        }
};

class Dog : public Animal {
    public:
        void sound() {
            std::cout << "This is a dog sound." << std::endl;
        }
};

int main() {
    Animal animal;
    Dog dog;

    animal.sound(); // 输出 "This is an animal sound."
    dog.sound();    // 输出 "This is a dog sound."

    return 0;
}

多态示例

多态允许父类指针指向子类对象，通过父类指针调用子类的方法。

#include <iostream>

class Animal {
    public:
        virtual void sound() {
            std::cout << "This is an animal sound." << std::endl;
        }
};

class Dog : public Animal {
    public:
        void sound() {
            std::cout << "This is a dog sound." << std::endl;
        }
};

int main() {
    Animal* animal = new Dog();
    animal->sound(); // 输出 "This is a dog sound."

    delete animal;

    return 0;
}

封装与抽象类

封装是指将数据和操作数据的方法绑定在一起，防止外部直接访问成员变量。

封装示例

#include <iostream>

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

    public:
        Person(std::string n, int a) : name(n), age(a) {}

        void setName(std::string n) {
            name = n;
        }

        void setAge(int a) {
            age = a;
        }

        std::string getName() {
            return name;
        }

        int getAge() {
            return age;
        }
};

int main() {
    Person person("Alice", 25);
    person.setName("Bob");
    person.setAge(30);

    std::cout << "Name: " << person.getName() << ", Age: " << person.getAge() << std::endl;

    return 0;
}

抽象类示例

抽象类是一种不能直接实例化的类，用于定义抽象方法。

#include <iostream>

class Animal {
    public:
        virtual void sound() = 0;
};

class Dog : public Animal {
    public:
        void sound() {
            std::cout << "This is a dog sound." << std::endl;
        }
};

int main() {
    Dog dog;
    dog.sound(); // 输出 "This is a dog sound."

    return 0;
}

接口与实现分离

通过接口与实现分离，可以将类的功能分为接口和实现两个部分，提高代码的可维护性和扩展性。

接口示例

#include <iostream>

class AnimalInterface {
    public:
        virtual void sound() = 0;
};

class Dog : public AnimalInterface {
    public:
        void sound() {
            std::cout << "This is a dog sound." << std::endl;
        }
};

int main() {
    Dog dog;
    dog.sound(); // 输出 "This is a dog sound."

    return 0;
}

总结

本节介绍了面向对象编程的进阶概念，包括继承与多态、封装与抽象类，以及接口与实现分离。通过这些内容的学习，你将能够编写更健壮和灵活的C++程序。至此，你已经掌握了C++开发的基本概念和技术，可以开始编写更复杂的程序了。希望你能够继续深入学习和实践，不断提升自己的编程技能。