C++编程入门：基础概念与实战教程-原创手记-慕课网

概述

本文详细介绍了C++编程入门的基础概念和实战教程，涵盖语言基础、语法结构、控制结构、函数与作用域以及面向对象编程等内容。通过本文的学习，读者可以掌握C++编程入门所需的基本知识和技能。从安装配置开发环境到编写简单的程序，每一步都进行了详细的讲解。希望读者能够通过实践进一步巩固所学的C++编程入门知识。

C++编程入门：基础概念与实战教程

C++编程基础概念

什么是C++

C++是一种静态类型的、编译式的、通用、大小写敏感的、既面向过程又面向对象的编程语言。它由Bjarne Stroustrup于1983年在贝尔实验室开发，广泛用于高级编程任务。C++支持多种编程范式，包括过程化、面向对象和泛型编程。

C++的发展历程

C++语言的发展历程可以大致分为以下几个阶段：

C++ 1.0：1983年，Bjarne Stroustrup开发了C++的前身“C with Classes”。
C++ 2.0：1985年发布，引入了虚函数、运算符重载、类模板等特性。
C++ 3.0：1989年发布，增加了RTTI（运行时类型信息）、异常处理等特性。
C++ 4.0：1992年发布，引入了标准模板库（STL）。
C++ 5.0（ANSI/ISO C++）：1998年发布，成为国际标准。
C++ 6.0（C++03）：2003年发布，进行了细微的修订。
C++ 7.0（C++0X）：2011年发布，引入了C++11标准，带来了lambda表达式、范围for循环等新特性。
C++ 8.0（C++14）：2014年发布，增加了泛型编程的灵活性。
C++ 9.0（C++17）：2017年发布，引入了结构化绑定、文件系统库等特性。
C++ 10.0（C++20）：2020年发布，引入了概念、三波集合等新特性。
C++ 11.0（C++23）：2023年发布，带来了更多的新特性和库。

C++的基本语法结构

C++的基本语法结构包括程序结构、注释、变量类型和基本的控制结构。一个C++程序通常由几个主要部分组成：预处理指令、全局变量声明、函数定义和一个main函数。

#include <iostream> // 引入标准输入输出库

int main() {
    std::cout << "Hello, World!" << std::endl; // 输出"Hello, World!"
    return 0; // 返回0表示程序正常结束
}

安装和配置开发环境

安装C++开发环境需要选择合适的IDE（集成开发环境）并安装相应的编译器和库。常见的IDE包括：

Visual Studio：适用于Windows系统
Code::Blocks：跨平台，易于使用
CLion：由JetBrains开发，专门为C++设计
Visual Studio Code：配合C++扩展插件使用

安装步骤如下：

安装IDE
- 下载并安装选择的IDE。
- 对于Visual Studio和CLion，安装过程中需要选择C++支持。
安装编译器
- Windows：安装Microsoft Visual C++可再发行组件。
- macOS：安装Apple的Xcode或使用Homebrew安装GCC。
- Linux：使用包管理器安装GCC。
安装支持库
- 使用包管理器安装必要的库。

配置IDE的步骤：

配置编译器路径
- 在IDE中设置正确的编译器路径。
配置编译选项
- 设置编译选项，如调试级别、优化级别等。
配置运行配置
- 设置运行程序的环境变量和参数。

C++基本语法入门

变量和数据类型

C++中的变量用来存储数据。C++的变量类型包括基本的数据类型，如整型、浮点型、字符型等，以及复合类型，如数组、结构等。

基本数据类型

整型：int、short、long、long long
浮点型：float、double、long double
字符型：char
布尔型：bool

#include <iostream>

int main() {
    int myInt = 42; // 整型变量
    float myFloat = 3.14; // 浮点型变量
    char myChar = 'A'; // 字符变量
    bool myBool = true; // 布尔型变量

    std::cout << "整型变量: " << myInt << std::endl;
    std::cout << "浮点型变量: " << myFloat << std::endl;
    std::cout << "字符变量: " << myChar << std::endl;
    std::cout << "布尔型变量: " << myBool << std::endl;

    return 0;
}

常量和关键字

常量是不可更改的值。C++中可以通过const关键字定义常量。

#include <iostream>

int main() {
    const double PI = 3.14159;
    std::cout << "PI: " << PI << std::endl;

    return 0;
}

C++的关键字是一些特殊的保留字，不能用作变量名或其他标识符。常见的关键字包括int、if、else、for、while、return等。

运算符及其优先级

C++支持多种运算符，包括算术运算符（如+、-、*、/）、关系运算符（如==、!=、<、>）、逻辑运算符（如&&、||）等。运算符的优先级决定了表达式的计算顺序。

#include <iostream>

int main() {
    int a = 4;
    int b = 2;
    int result;

    // 算术运算
    result = (a + b) * 2;
    std::cout << "结果: " << result << std::endl;

    // 关系运算
    bool isGreater = a > b;
    std::cout << "a 是否大于 b: " << isGreater << std::endl;

    // 逻辑运算
    bool logic = (a > b) && (a < 10);
    std::cout << "逻辑表达式: " << logic << std::endl;

    return 0;
}

输入输出流

C++提供了标准的输入输出流库，包括iostream。cout用于输出，cin用于输入。

#include <iostream>

int main() {
    std::cout << "请输入你的名字: ";
    std::string name;
    std::cin >> name;

    std::cout << "你好, " << name << "!" << std::endl;

    return 0;
}

注释

C++中的注释有两种形式，单行注释（以//开始）和多行注释（以/*开始，以*/结束）。

#include <iostream>

int main() {
    // 这是一个单行注释
    /* 这是一个
       多行注释 */
    std::cout << "Hello, World!" << std::endl; // 输出"Hello, World!"

    return 0;
}

C++控制结构

条件语句（if...else）

条件语句用于根据条件选择代码的执行路径。

#include <iostream>

int main() {
    int age = 20;

    if (age >= 18) {
        std::cout << "你已经成年了!" << std::endl;
    } else {
        std::cout << "你还未成年!" << std::endl;
    }

    return 0;
}

循环语句（for, while, do...while）

循环语句用于重复执行一段代码。循环语句包括for、while和do...while。

#include <iostream>

int main() {
    // for 循环
    for (int i = 0; i < 5; i++) {
        std::cout << "循环次数: " << i << std::endl;
    }

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

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

    return 0;
}

分支结构

分支结构包括条件语句和循环语句，用于控制程序的流程。

#include <iostream>

int main() {
    int number = 10;
    switch (number) {
        case 0:
            std::cout << "number is 0" << std::endl;
            break;
        case 1:
            std::cout << "number is 1" << std::endl;
            break;
        case 10:
            std::cout << "number is 10" << std::endl;
            break;
        default:
            std::cout << "number is not 0, 1, or 10" << std::endl;
    }

    return 0;
}

跳转语句（break, continue）

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

#include <iostream>

int main() {
    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            continue; // 跳过当前循环
        }
        if (i == 7) {
            break; // 结束循环
        }
        std::cout << "数字: " << i << std::endl;
    }

    return 0;
}

C++函数与作用域

函数定义与调用

函数是可重用的一段代码，用来执行特定的任务。函数定义包括函数名、参数列表、返回类型和函数体。

#include <iostream>

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

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

    return 0;
}

函数参数与返回值

函数可以接受参数，也可以返回值。参数可以是任意类型，返回值类型由函数声明决定。

#include <iostream>

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

int main() {
    int result = sum(5, 10);
    std::cout << "结果: " << result << std::endl;

    return 0;
}

函数重载

函数重载允许定义多个具有相同名字但参数列表不同的函数。

#include <iostream>

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

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

int main() {
    int intResult = add(3, 4);
    std::cout << "整型结果: " << intResult << std::endl;

    double doubleResult = add(3.5, 4.5);
    std::cout << "浮点型结果: " << doubleResult << std::endl;

    return 0;
}

局部变量与全局变量

局部变量在函数内部声明，仅在函数内部可见。全局变量在所有函数外部声明，可以被所有函数访问。

#include <iostream>

int globalVar = 10; // 全局变量

int main() {
    int localVar = 20; // 局部变量

    std::cout << "全局变量: " << globalVar << std::endl;
    std::cout << "局部变量: " << localVar << std::endl;

    return 0;
}

作用域规则

作用域规则定义了变量的有效范围。局部变量的作用域只限于定义它的函数内部，全局变量的作用域则在整个程序中。

#include <iostream>

int globalVar = 10; // 全局变量

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

int main() {
    std::cout << "全局变量: " << globalVar << std::endl;

    func();

    return 0;
}

C++数组与指针

数组的定义与使用

数组是一组相同类型的元素的集合，可以通过索引访问元素。

#include <iostream>

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

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

    return 0;
}

字符串的操作

字符串是字符数组，可以用char类型定义。

#include <iostream>

int main() {
    char str[10] = "Hello";

    for (int i = 0; str[i] != '\0'; i++) {
        std::cout << "字符 " << i << ": " << str[i] << std::endl;
    }

    return 0;
}

指针的基本概念

指针是一个变量，存储了另一个变量的地址。通过指针可以访问和修改变量的值。

#include <iostream>

int main() {
    int num = 42;
    int* pNum = &num; // pNum 指向 num

    std::cout << "num 的值: " << num << std::endl;
    std::cout << "pNum 的值: " << pNum << std::endl;
    std::cout << "通过指针访问 num: " << *pNum << std::endl;

    *pNum = 20; // 修改 num 的值
    std::cout << "修改后的 num 的值: " << num << std::endl;

    return 0;
}

指针与数组的关系

数组名可以被视为指向数组第一个元素的指针。

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* pArr = arr; // pArr 指向 arr 的第一个元素

    for (int i = 0; i < 5; i++) {
        std::cout << "数组元素 " << i << ": " << *(pArr + i) << std::endl;
    }

    return 0;
}

动态内存分配

动态内存分配允许在运行时分配内存。主要的分配和释放函数分别是new和delete。

#include <iostream>

int main() {
    int* pNum = new int; // 分配内存
    *pNum = 42; // 赋值
    std::cout << "pNum 的值: " << *pNum << std::endl;

    delete pNum; // 释放内存
    pNum = nullptr; // 避免悬挂指针

    return 0;
}

C++面向对象编程基础

类与对象的概念

类是一种用户自定义的数据类型，可以包含数据成员（变量）和成员函数（方法）。对象是类的实例，具有类的属性和行为。

#include <iostream>

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

    void introduce() {
        std::cout << "我是 " << name << ", 我 " << age << " 岁." << std::endl;
    }
};

int main() {
    Person p1;
    p1.name = "张三";
    p1.age = 20;

    p1.introduce();

    return 0;
}

成员变量与成员函数

类中的成员变量表示对象的状态，成员函数表示对象的行为。

#include <iostream>

class Rectangle {
public:
    int width;
    int height;

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

int main() {
    Rectangle rect;
    rect.width = 10;
    rect.height = 5;

    std::cout << "矩形面积: " << rect.area() << std::endl;

    return 0;
}

构造函数与析构函数

构造函数用于初始化对象，析构函数用于清理对象。

#include <iostream>

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

    Person(std::string name, int age) : name(name), age(age) {} // 构造函数
    ~Person() {} // 析构函数
};

int main() {
    Person p1("张三", 20);
    p1.introduce();

    return 0;
}

继承与重载

继承允许一个类（子类）继承另一个类（父类）的属性和方法。重载允许定义多个具有相同名字但参数列表不同的方法。

#include <iostream>

class Animal {
public:
    void speak() {
        std::cout << "动物发声." << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪叫." << std::endl;
    }
};

int main() {
    Animal animal;
    Dog dog;

    animal.speak();
    dog.speak();

    return 0;
}

封装与多态

封装是将数据和操作数据的方法捆绑在一起。多态允许使用相同的方法名称实现不同的行为。

#include <iostream>

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数，表示接口
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "绘制正方形" << std::endl;
    }
};

class EncapsulatedShape {
private:
    Shape* shape;

public:
    EncapsulatedShape(Shape* shape) : shape(shape) {}

    void draw() {
        shape->draw();
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Square();

    EncapsulatedShape circleEncap(new Circle());
    EncapsulatedShape squareEncap(new Square());

    circleEncap.draw();
    squareEncap.draw();

    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();
    }

    delete shapes[0];
    delete shapes[1];

    return 0;
}

综合案例

下面是一个综合案例，展示了类的使用、继承、多态等概念。

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "动物发声." << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪叫." << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() {
        std::cout << "喵喵叫." << std::endl;
    }
};

int main() {
    Animal animal;
    Dog dog;
    Cat cat;

    animal.speak();
    dog.speak();
    cat.speak();

    return 0;
}

结论

通过以上内容的学习，你已经掌握了C++编程的基础知识，包括基本语法、控制结构、函数、对象、数组、指针以及面向对象编程的概念。接下来，你可以通过更多的实践和项目来加深理解和应用这些知识。推荐使用慕课网进行更深入的学习。