C++0基础学习：从入门到初级实战-原创手记-慕课网

概述

本文详细介绍了C++0基础学习的内容，包括语言发展历程、编程环境搭建、基本语法、函数使用、数组与指针、结构体与类以及简单项目实践，帮助初学者快速掌握C++编程技能。

C++语言简介

C++语言的发展历程

C++语言由Bjarne Stroustrup在20世纪80年代早期开发，最初的版本名为“C with Classes”，它是在C语言基础上加入了面向对象编程的特性。C++在1983年正式发布，并在随后的数十年中不断演进，逐渐成为一种功能强大、灵活且广泛应用的语言。早期的C++版本主要集中在面向对象编程的特性上，随着语言的发展，更多现代特性（如泛型编程支持）也被加入。

C++与C语言的区别

C++是在C语言的基础上发展起来的，因此C++包含了C语言的所有特性，同时增加了面向对象编程的支持。以下是两者的一些主要区别：

面向对象支持：C++支持类、对象、继承、多态等面向对象的概念，而C语言是过程式的，不支持面向对象的概念。
模板：C++支持泛型编程，允许使用模板来创建可重用的代码，C语言不支持模板。
异常处理：C++支持异常处理，可以在程序中捕获和处理运行时错误，而C语言没有内置的异常处理机制。
函数重载：C++支持函数重载，允许同名函数接受不同类型的参数或数量不等的参数，C语言不支持函数重载。
名称空间：C++支持名称空间，可以防止命名冲突，C语言没有名称空间的概念。

C++编程环境搭建

为了开始编写C++代码，你需要在计算机上安装一个支持C++的开发环境。以下是常用的开发环境及其搭建方法：

Visual Studio Code：
这是一个轻量级的编辑器，它支持各种编程语言，并且有丰富的插件支持。你可以通过安装C++扩展来开始编写C++代码。安装教程如下：
1. 下载并安装Visual Studio Code。
2. 打开Visual Studio Code，点击左侧活动栏中的扩展图标（四个方块组成的图标）。
3. 在扩展搜索框中输入“C++”，找到Microsoft提供的C++扩展，点击安装。
以下是一个简单的C++项目的创建和运行示例：
```
#include <iostream>

int main() {
   std::cout << "Hello, World!" << std::endl;
   return 0;
}
```
将上述代码保存为hello.cpp，然后在命令行中使用g++编译并运行：
```
g++ hello.cpp -o hello
./hello
```
Visual Studio：
这是Microsoft提供的一个全面的集成开发环境（IDE），它支持多种编程语言，包括C++。下载和安装教程如下：
1. 访问Visual Studio官网，下载并安装适用于Windows、macOS或Linux的版本。
2. 选择"Use the workloads selector"，选择“Desktop development with C++”，然后点击安装。
Code::Blocks：
这是一个跨平台的开源IDE，支持多种编程语言，包括C++。安装教程如下：
1. 访问Code::Blocks官网下载页面，选择适合你操作系统的版本并下载。
2. 安装Code::Blocks，并确保安装过程中选择安装C++编译器（如GCC）。
命令行编译器：
如果你更喜欢使用命令行工具，可以安装GCC（GNU Compiler Collection）编译器。
1. 在Windows上，可以通过安装MinGW来安装GCC。
2. 在macOS上，可以使用Homebrew来安装GCC。
3. 在Linux上，可以直接使用包管理器来安装GCC。

一旦安装了开发环境，你需要创建一个新的C++项目并编写一个简单的“Hello, World!”程序来测试环境是否配置成功。以下是一个简单的示例：

#include <iostream>

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

将这段代码保存为hello.cpp，然后使用相应的编译器进行编译和运行。例如，使用GCC编译器，可以在命令行中执行以下命令：

g++ hello.cpp -o hello
./hello

这将把hello.cpp编译成为可执行文件，并运行它。如果一切正常，你应该在输出中看到“Hello, World!”。

C++基本语法

变量与数据类型

在C++程序中，变量是用来存储数据的标识符。C++提供了多种数据类型，包括整型、浮点型、字符型等。以下是常用的数据类型及其示例：

整型：表示整数数据。
- int：普通的整数类型，通常是32位。
- short：短整型，通常占用16位。
- long：长整型，通常是32位或64位，取决于平台。
- long long：更长的整型，通常是64位。
浮点型：表示浮点数。
- float：单精度浮点数，通常是32位。
- double：双精度浮点数，通常是64位。
- long double：扩展双精度浮点数，通常是80位或128位，取决于平台。
字符型：表示字符数据。
- char：表示单个字符，通常是8位。
- wchar_t：宽字符，通常是16位或32位，取决于平台。
布尔型：表示布尔值，只有两个可能的值：true和false。

变量的声明包括指定类型和变量名。例如：

int age = 25;          // 整型变量
float price = 19.99;   // 浮点型变量
char grade = 'A';      // 字符型变量
bool isStudent = true; // 布尔型变量

运算符及其优先级

C++支持多种运算符，包括算术运算符、逻辑运算符、位运算符等。理解运算符的优先级和结合性对于编写正确的表达式非常重要。以下是一些基本的运算符及其优先级：

算术运算符：+（加）、-（减）、*（乘）、/（除）、%（取模）。
赋值运算符：=
逻辑运算符：&&（逻辑与）、||（逻辑或）、!（逻辑非）。
关系运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。

运算符的优先级决定了表达式的计算顺序。例如，算术运算符的优先级高于关系运算符，关系运算符的优先级高于逻辑运算符。在相同优先级的情况下，运算符的结合性决定了计算的顺序，通常是从左到右。

示例：

int a = 10, b = 5, c = 2;
int result = (a + b) * c / 2; // 优先级：先加，再乘，再除
bool isGreater = a > b && b > c; // 优先级：先比较，再逻辑与

控制结构（条件语句和循环语句）

控制结构用于控制程序的执行流程。C++中的控制结构包括条件语句（如if、switch）和循环语句（如for、while）。

条件语句

if语句：

用于简单条件判断。

if (age >= 18) {
std::cout << "You are an adult." << std::endl;
}

if-else语句：

用于条件判断后的两种情况。

if (grade == 'A') {
std::cout << "Excellent!" << std::endl;
} else {
std::cout << "Try harder." << std::endl;
}

if-else-if链：

用于多种条件判断。

if (score >= 90) {
std::cout << "A" << std::endl;
} else if (score >= 80) {
std::cout << "B" << std::endl;
} else if (score >= 70) {
std::cout << "C" << std::endl;
} else {
std::cout << "Fail" << std::endl;
}

switch语句：

用于多个条件的选择。

switch (grade) {
case 'A':
   std::cout << "Excellent!" << std::endl;
   break;
case 'B':
   std::cout << "Good." << std::endl;
   break;
case 'C':
   std::cout << "Average." << std::endl;
   break;
default:
   std::cout << "Fail." << std::endl;
}

循环语句

for循环：

用于已知迭代次数的循环。

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

while循环：

用于条件满足时的循环。

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

do-while循环：

用于至少执行一次的循环。

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

示例代码

#include <iostream>

int main() {
    int score = 85;
    if (score >= 90) {
        std::cout << "A" << std::endl;
    } else if (score >= 80) {
        std::cout << "B" << std::endl;
    } else if (score >= 70) {
        std::cout << "C" << std::endl;
    } else {
        std::cout << "Fail" << std::endl;
    }

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

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

    return 0;
}

函数使用

函数定义与调用

函数是C++中的基本构建块，用于封装一段可重用的代码。每个函数都有一个特定的功能，并且可以通过调用来执行该功能。函数定义包括返回类型、函数名、参数列表和函数体。

函数定义

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

函数调用

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

参数传递与返回值

函数可以有任意数量的参数，也可以没有参数。参数可以按值传递（默认方式）或按引用传递。返回值是指函数执行完毕后返回给调用者的值。

按值传递

int square(int n) {
    return n * n;
}

int x = 5;
int y = square(x);
std::cout << "Square of " << x << " is " << y << std::endl;

按引用传递

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

int main() {
    int x = 5, y = 10;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swap(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;
    return 0;
}

函数重载

函数重载允许有相同的函数名，但参数列表不同。这样可以实现相同功能的不同版本。

示例

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

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

int main() {
    int intResult = add(3, 5);
    double doubleResult = add(3.5, 5.5);
    std::cout << "intResult: " << intResult << std::endl;
    std::cout << "doubleResult: " << doubleResult << std::endl;
    return 0;
}

数组与指针

一维数组与二维数组

数组是一种可以存储多个相同类型值的数据结构。一维数组和二维数组是数组的两种常见形式。

一维数组

int numbers[] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
    std::cout << "Element " << i << ": " << numbers[i] << std::endl;
}

二维数组

int matrix[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 << "Matrix[" << i << "][" << j << "]: " << matrix[i][j] << std::endl;
    }
}

字符串处理

字符串在C++中可以使用char数组或std::string类来表示。std::string提供了更多的字符串操作功能。

使用`char`数组

char str[20] = "Hello, World!";
std::cout << str << std::endl;

使用`std::string`

std::string s = "Hello, World!";
s += "!";
std::cout << s << std::endl;

字符串操作

std::string s = "Hello, World!";
std::cout << "Length: " << s.length() << std::endl;
std::cout << "Substring: " << s.substr(7, 5) << std::endl;
std::cout << "Find 'World': " << s.find("World") << std::endl;
std::cout << "Replace 'World': " << s.replace(7, 5, "Universe") << std::endl;
std::cout << "Split: " << s << std::endl;

指针与地址

指针是一种特殊的变量，用于存储另一个变量的地址。指针的使用可以提高程序的灵活性和效率。

获取指针的地址

int value = 10;
int *p = &value;
std::cout << "Address of value: " << p << std::endl;

通过指针访问值

*p = 20;
std::cout << "Value: " << value << std::endl;

示例代码

#include <iostream>
#include <string>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        std::cout << "Element " << i << ": " << numbers[i] << std::endl;
    }

    int matrix[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 << "Matrix[" << i << "][" << j << "]: " << matrix[i][j] << std::endl;
        }
    }

    char str[20] = "Hello, World!";
    std::cout << str << std::endl;

    std::string s = "Hello, World!";
    s += "!";
    std::cout << s << std::endl;

    int value = 10;
    int *p = &value;
    std::cout << "Address of value: " << p << std::endl;
    *p = 20;
    std::cout << "Value: " << value << std::endl;

    return 0;
}

结构体与类

结构体的定义与使用

结构体是一种用户自定义的数据类型，用于存储一组相关的变量。结构体可以包含不同类型的成员变量，但不能包含成员函数。

定义结构体

struct Point {
    int x;
    int y;
};

Point p;
p.x = 10;
p.y = 20;

使用结构体

#include <iostream>

int main() {
    struct Point {
        int x;
        int y;
    };

    Point p;
    p.x = 10;
    p.y = 20;
    std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;
    return 0;
}

类的定义与成员

类是一种用户自定义的数据类型，可以包含成员变量和成员函数。类提供了封装数据和操作数据的功能，可以实现面向对象编程。

定义类

class Rectangle {
public:
    int width;
    int height;

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

Rectangle r;
r.width = 10;
r.height = 20;
std::cout << "Area: " << r.area() << std::endl;

类的封装与继承

封装是指将数据和操作数据的函数封装在一起，以实现数据的隐藏和操作的封装。继承允许一个类继承另一个类的属性和行为。

封装示例

class BankAccount {
private:
    double balance;

public:
    BankAccount(double initialBalance) {
        balance = initialBalance;
    }

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

    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds!" << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }
};

BankAccount account(1000);
account.deposit(500);
account.withdraw(200);
std::cout << "Balance: " << account.getBalance() << std::endl;

继承示例

class Shape {
public:
    virtual double area() = 0;
};

class Rectangle : public Shape {
private:
    int width;
    int height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}

    double area() override {
        return width * height;
    }
};

Rectangle r(10, 20);
std::cout << "Area: " << r.area() << std::endl;

示例代码

#include <iostream>

struct Point {
    int x;
    int y;
};

class BankAccount {
private:
    double balance;

public:
    BankAccount(double initialBalance) {
        balance = initialBalance;
    }

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

    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds!" << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }
};

class Shape {
public:
    virtual double area() = 0;
};

class Rectangle : public Shape {
private:
    int width;
    int height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}

    double area() override {
        return width * height;
    }
};

int main() {
    Point p;
    p.x = 10;
    p.y = 20;
    std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;

    BankAccount account(1000);
    account.deposit(500);
    account.withdraw(200);
    std::cout << "Balance: " << account.getBalance() << std::endl;

    Rectangle r(10, 20);
    std::cout << "Area: " << r.area() << std::endl;

    return 0;
}

基础项目实践

简单控制台应用开发

开发简单的控制台应用程序可以帮助你更好地理解C++的基本概念。以下是一个简单的控制台应用示例，该应用允许用户输入名字并显示欢迎消息。

示例代码

#include <iostream>
#include <string>

int main() {
    std::string name;
    std::cout << "Please enter your name: ";
    std::cin >> name;
    std::cout << "Hello, " << name << "!" << std::endl;
    return 0;
}

小型项目案例分析与实现

开发一个简单的分数计算器可以帮助你练习使用C++中的类和函数。该计算器允许用户输入两个分数，并执行加、减、乘、除运算。

示例代码


#include <iostream>
#include <string>

using namespace std;

class Fraction {
private:
    int numerator;
    int denominator;

public:
    Fraction(int num, int den) : numerator(num), denominator(den) {}

    void setNumerator(int num) {
        numerator = num;
    }

    void setDenominator(int den) {
        denominator = den;
    }

    int getNumerator() const {
        return numerator;
    }

    int getDenominator() const {
        return denominator;
    }

    void simplify() {
        int gcd = gcd(numerator, denominator);
        numerator /= gcd;
        denominator /= gcd;
    }

    // Helper function to find the greatest common divisor
    int gcd(int a, int b) const {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    friend Fraction addFractions(const Fraction &f1, const Fraction &f2);
    friend Fraction subtractFractions(const Fraction &f1, const Fraction &f2);
    friend Fraction multiplyFractions(const Fraction &f1, const Fraction &f2);
    friend Fraction divideFractions(const Fraction &f1, const Fraction &f2);
};

Fraction addFractions(const Fraction &f1, const Fraction &f2) {
    int numerator = f1.getNumerator() * f2.getDenominator() + f2.getNumerator() * f1.getDenominator();
    int denominator = f1.getDenominator() * f2.getDenominator();
    Fraction result(numerator, denominator);
    result.simplify();
    return result;
}

Fraction subtractFractions(const Fraction &f1, const Fraction &f2) {
    int numerator = f1.getNumerator() * f2.getDenominator() - f2.getNumerator() * f1.getDenominator();
    int denominator = f1.getDenominator() * f2.getDenominator();
    Fraction result(numerator, denominator);
    result.simplify();
    return result;
}

Fraction multiplyFractions(const Fraction &f1, const Fraction &f2) {
    int numerator = f1.getNumerator() * f2.getNumerator();
    int denominator = f1.getDenominator() * f2.getDenominator();
    Fraction result(numerator, denominator);
    result.simplify();
    return result;
}

Fraction divideFractions(const Fraction &f1, const Fraction &f2) {
    int numerator = f1.getNumerator() * f2.getDenominator();
    int denominator = f1.getDenominator() * f2.getNumerator();
    Fraction result(numerator, denominator);
    result.simplify();
    return result;
}

int main() {
    Fraction f1(1, 3);
    Fraction f2(1, 2);

    cout << "Add: " << addFractions(f1, f2).getNumerator() << "/" << addFractions(f1, f2).getDenominator() << endl;
    cout << "Subtract: " << subtractFractions(f1, f2).getNumerator() << "/" << subtractFractions(f1, f2).getDenominator() << endl;
    cout << "Multiply: " << multiplyFractions(f1, f2).getNumerator() << "/" << multiplyFractions(f1, f2).getDenominator() << endl;
    cout << "Divide: " << divideFractions(f1, f2).getNumerator() << "/" << divideFractions(f1, f2).getDenominator() << endl;

    return 0;
}
``