为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 C++开发入门教程：从零开始掌握C++编程

C++开发入门教程：从零开始掌握C++编程

标签：
C++
概述

本文详细介绍了C++开发环境的搭建步骤，涵盖安装和配置必要的开发工具、选择合适的集成开发环境（IDE），以及创建第一个C++项目的具体方法。文章还介绍了C++的基础语法和结构化编程知识，帮助读者从零开始掌握C++开发的关键技能。文中提供了丰富的示例代码和详细的操作指南，确保读者能够顺利入门C++开发。

C++开发环境搭建

安装和配置开发工具

在开始学习C++编程前，首先需要搭建一个合适的开发环境。对于初学者，选择一个强大的集成开发环境（IDE）是非常重要的。以下是安装和配置开发工具的步骤：

  1. 下载并安装C++编译器：最常用的C++编译器是GCC（GNU Compiler Collection）。安装GCC可以通过各种包管理工具来完成。例如，在Ubuntu系统中，可以通过以下命令安装GCC：

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

  2. 安装辅助工具：为了更好地开发和调试C++程序，还需要安装一些辅助工具。例如，使用make工具来管理编译过程。在Ubuntu中，可以通过以下命令安装make：

    sudo apt-get install make

  3. 安装调试工具：调试工具如gdb（GNU Debugger）可以帮助你更好地理解和解决程序中的错误。同样，可以通过包管理工具安装gdb：

    sudo apt-get install gdb

  4. 配置环境变量：确保安装的工具可以在命令行中使用。编辑~/.bashrc或~/.zshrc文件，添加以下环境变量（根据实际情况替换路径）：

    export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games

选择合适的IDE

为了提供最佳的编程体验，选择一个合适的IDE（集成开发环境）是十分重要的。以下是一些常用的IDE及其安装步骤：

  1. Visual Studio Code：

    • 安装Visual Studio Code（VS Code）：可以前往官网下载安装包。
    • 安装C++扩展：打开VS Code，点击左侧活动栏的扩展图标，搜索C++，安装Microsoft提供的C++扩展。
    • 配置VS Code：可以通过安装C/C++扩展的设置来配置编译器路径等信息。

  2. CLion：

    • 安装CLion：可以从官网下载安装包。
    • 安装并配置C++环境：启动CLion后，按照提示选择正确的C++编译器路径。
  3. Code::Blocks：
    • 安装Code::Blocks：可以从官网下载安装包。
    • 安装并配置C++编译器：在安装过程中选择正确的编译器路径，或者在安装完成后手动配置。

创建第一个C++项目和Hello World程序

创建一个新的C++项目和编写第一个“Hello World”程序是开始学习的第一步。以下是如何在Visual Studio Code中创建并运行这个程序：

  1. 创建新文件夹：在你的工作目录中创建一个新文件夹，例如MyFirstCPPProject。

  2. 创建main.cpp文件：打开VS Code，选择File -> New File，输入以下代码：

    #include <iostream>

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

  3. 配置任务文件：打开VS Code的终端，输入以下命令来生成任务文件：

    code --list-extensions
code --list-commands
code --install-extension ms-vscode.cpptools
code --locate-workspace-folder
code --open-folder ./MyFirstCPPProject

  4. 运行程序：在VS Code中打开命令面板（Ctrl+Shift+P），选择Tasks: Run Build Task，然后选择build（如果没有自动创建，可以手动创建tasks.json文件）。

    {
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "g++",
            "args": [
                "-g",
                "-std=c++11",
                "main.cpp",
                "-o",
                "main"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "problemMatcher": [
                "$gcc"
            ]
        }
    ]
}

  5. 运行生成的可执行文件：在终端中输入以下命令来运行生成的可执行文件：

    ./main

C++基础语法

变量和数据类型

在C++中，变量用于存储数据，每个变量都有一个类型，该类型指定了变量可以存储的数据类型。C++提供了多种内置的数据类型，包括整型、浮点型、字符型等。

  1. 整型变量：

    • int：用于存储整数（32位）。
    • short：用于存储短整型（16位）。
    • long：用于存储长整型（32位或64位，取决于平台）。
    • long long：用于存储更长的整数（64位）。

  2. 浮点型变量：

    • float：用于存储单精度浮点数（32位）。
    • double：用于存储双精度浮点数（64位）。
    • long double：用于存储延伸精度浮点数（通常也是64位，但在某些平台上可能更大）。
  3. 字符型变量：
    • char：用于存储字符（8位，通常与ASCII字符集兼容）。
    • wchar_t：用于存储宽字符（通常是16位或32位，取决于平台）。

示例代码：

#include <iostream>

int main() {
    int a = 5;
    short b = 10;
    long c = 100000;
    long long d = 10000000000LL;

    float e = 3.14f;
    double f = 2.718;
    long double g = 1.234567890123456;

    char h = 'A';
    wchar_t i = L'B';

    std::cout << "int: " << a << std::endl;
    std::cout << "short: " << b << std::endl;
    std::cout << "long: " << c << std::endl;
    std::cout << "long long: " << d << std::endl;

    std::cout << "float: " << e << std::endl;
    std::cout << "double: " << f << std::endl;
    std::cout << "long double: " << g << std::endl;

    std::cout << "char: " << h << std::endl;
    std::cout << "wchar_t: " << i << std::endl;

    return 0;
}

常量和符号常量

在C++中，常量用于存储固定不变的值。常量分为两种类型：编译时常量和运行时常量。

  1. 编译时常量：

    • 使用const关键字定义编译时常量：

      const int MAX_VALUE = 100;

  2. 运行时常量：

    • 使用constexpr定义常量：

      constexpr int MAX_VALUE = 100;

  3. 符号常量：

    • 使用#define宏定义符号常量：

      #define PI 3.14159265359

示例代码：

#include <iostream>

const int MAX_VALUE = 100;
constexpr int MAX_VALUE_2 = 100;
#define PI 3.14159265359

int main() {
    std::cout << "MAX_VALUE: " << MAX_VALUE << std::endl;
    std::cout << "MAX_VALUE_2: " << MAX_VALUE_2 << std::endl;
    std::cout << "PI: " << PI << std::endl;

    return 0;
}

输入输出操作（cin, cout）

C++提供了<iostream>库来支持输入输出操作。使用std::cin进行输入，使用std::cout进行输出。

  1. 输出操作：

    • std::cout用于输出数据到标准输出设备（通常是屏幕）：

      std::cout << "Hello, World!" << std::endl;

  2. 输入操作：

    • std::cin用于从标准输入设备（通常是键盘）读取数据：

      int number;
std::cout << "Enter a number: ";
std::cin >> number;
std::cout << "You entered: " << number << std::endl;

示例代码：

#include <iostream>

int main() {
    int number;
    std::cout << "Enter a number: ";
    std::cin >> number;
    std::cout << "You entered: " << number << std::endl;

    return 0;
}

控制结构（if, switch, for, while等）

C++提供了多种控制结构来控制程序的流程。以下是一些常见的控制结构：

  1. if语句：

    • 用于单条件判断：

      if (number > 0) {
 std::cout << "Number is positive" << std::endl;
}

  2. if-else语句：

    • 用于多条件判断：

      if (number > 0) {
 std::cout << "Number is positive" << std::endl;
} else {
 std::cout << "Number is not positive" << std::endl;
}

  3. switch语句：

    • 用于多分支选择：

      int number = 2;
switch(number) {
 case 0:
     std::cout << "Number is zero" << std::endl;
     break;
 case 1:
     std::cout << "Number is one" << std::endl;
     break;
 case 2:
     std::cout << "Number is two" << std::endl;
     break;
 default:
     std::cout << "Number is not zero, one or two" << std::endl;
}

  4. for循环：

    • 用于执行固定次数的循环：

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

  5. while循环：

    • 用于条件满足时执行循环：

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

  6. do-while循环：

    • 用于至少执行一次循环：

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

示例代码：

#include <iostream>

int main() {
    int number = 3;
    if (number > 0) {
        std::cout << "Number is positive" << std::endl;
    } else {
        std::cout << "Number is not positive" << std::endl;
    }

    switch(number) {
        case 0:
            std::cout << "Number is zero" << std::endl;
            break;
        case 1:
            std::cout << "Number is one" << std::endl;
            break;
        case 2:
            std::cout << "Number is two" << std::endl;
            break;
        default:
            std::cout << "Number is not zero, one or two" << std::endl;
    }

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

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

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

    return 0;
}

函数和参数传递

定义和调用函数

函数是C++程序的基本组成部分，用于实现特定的功能。函数的定义包括函数名、返回类型、参数列表和函数体。

  1. 返回类型：

    • 定义函数时，需要指定返回类型。如果函数不返回任何值，可以使用void作为返回类型。

  2. 函数名：

    • 函数名应该具有描述性，表示函数的主要功能。

  3. 参数列表：

    • 参数列表可以为空，也可以包含多个参数。每个参数包括类型和名称。
  4. 函数体：
    • 函数体包含实现函数功能的代码。

示例代码：

#include <iostream>

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

void print(int number) {
    std::cout << "Number: " << number << std::endl;
}

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

    print(result);

    return 0;
}

参数传递（值传递、引用传递）

在C++中，参数可以通过值传递和引用传递两种方式传递：

  1. 值传递：

    • 值传递是将实际参数的副本传递给函数。

      void increment(int x) {
 x++;
}

int main() {
 int a = 5;
 increment(a);
 std::cout << "a: " << a << std::endl;  // 输出: a: 5
 return 0;
}

  2. 引用传递：

    • 引用传递是将实际参数的引用传递给函数。

      void increment(int& x) {
 x++;
}

int main() {
 int a = 5;
 increment(a);
 std::cout << "a: " << a << std::endl;  // 输出: a: 6
 return 0;
}

示例代码：

#include <iostream>

void increment(int& x) {
    x++;
}

int main() {
    int a = 5;
    std::cout << "Before increment: " << a << std::endl;
    increment(a);
    std::cout << "After increment: " << a << std::endl;
    return 0;
}

函数重载

函数重载是指在同一个作用域内可以定义多个同名函数，但这些函数的参数列表必须不同。函数重载可以提高代码的可读性和灵活性。

示例代码：

#include <iostream>

void print(int number) {
    std::cout << "Number: " << number << std::endl;
}

void print(double number) {
    std::cout << "Double number: " << number << std::endl;
}

int main() {
    int a = 5;
    double b = 3.14;

    print(a);
    print(b);

    return 0;
}

返回值类型与默认参数

函数可以返回多种类型的数据。默认参数可以为函数调用提供默认值，从而简化调用过程。

示例代码：

#include <iostream>

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

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

    result = add(3);  // 使用默认参数
    std::cout << "Result: " << result << std::endl;  // 输出: Result: 3

    return 0;
}

数组与指针

数组的定义和使用

数组是一种数据结构，用于存储固定数量的相同类型的数据元素。数组的定义包括数组名、类型和数组大小。

  1. 定义和初始化：

    • 通过指定数组大小定义数组：

      int numbers[5];

    • 初始化数组时，可以指定初始值：

      int numbers[5] = {1, 2, 3, 4, 5};

  2. 访问数组元素：

    • 使用索引访问数组元素：

      numbers[0] = 10;

  3. 遍历数组：

    • 使用循环遍历数组：

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

示例代码：

#include <iostream>

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

    numbers[0] = 10;

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

    return 0;
}

一维数组、二维数组

一维数组用于存储单个维度的数据，而二维数组用于存储二维数据结构。

  1. 定义和初始化一维数组：

    • 定义和初始化一维数组：

      int numbers[5] = {1, 2, 3, 4, 5};

  2. 定义和初始化二维数组：

    • 定义和初始化二维数组：

      int matrix[3][3] = {
 {1, 2, 3},
 {4, 5, 6},
 {7, 8, 9}
};

  3. 访问二维数组元素：

    • 使用索引访问二维数组元素：

      std::cout << matrix[0][0] << std::endl;  // 输出: 1

示例代码：

#include <iostream>

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

    for (int i = 0; i < 5; i++) {
        std::cout << 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] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

指针的概念与使用

指针是C++中一个非常重要的概念，用于存储变量的地址。指针可以提高程序的灵活性和效率。

  1. 定义和初始化指针：

    • 定义指针：

      int* ptr;

    • 初始化指针：

      int a = 5;
int* ptr = &a;

  2. 访问指针：

    • 使用指针访问和修改变量值：

      *ptr = 10;

  3. 指针的算术运算：

    • 使用指针进行算术运算：

      int numbers[5] = {1, 2, 3, 4, 5};
int* ptr = numbers;

ptr++;
ptr[0] = 10;

示例代码：

#include <iostream>

int main() {
    int a = 5;
    int* ptr = &a;

    *ptr = 10;

    std::cout << "a: " << a << std::endl;  // 输出: a: 10

    int numbers[5] = {1, 2, 3, 4, 5};
    int* ptr = numbers;

    ptr++;
    ptr[0] = 10;

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

    return 0;
}

指针与数组的关系

数组和指针之间存在紧密的关系，一个数组的名称可以被解释为指向该数组第一个元素的指针。

  1. 数组名与指针：

    • 数组名可以被解释为指向数组第一个元素的指针：

      int numbers[5] = {1, 2, 3, 4, 5};
int* ptr = numbers;

  2. 使用指针遍历数组：

    • 使用指针遍历数组：

      int numbers[5] = {1, 2, 3, 4, 5};
int* ptr = numbers;

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

示例代码：

#include <iostream>

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

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

    return 0;
}

结构化编程

结构体（struct）的定义与应用

结构体用于将多个不同类型的变量组合在一起，形成一个复合数据类型。结构体的定义包括结构体名和成员变量。

  1. 定义结构体：

    • 定义一个简单的结构体：

      struct Person {
 std::string name;
 int age;
};

  2. 使用结构体：

    • 创建结构体变量并访问成员变量：

      Person p;
p.name = "Alice";
p.age = 25;

  3. 结构体与函数的结合使用：

    • 在函数中使用结构体作为参数和返回值：

      struct Person {
 std::string name;
 int age;
};

void printPerson(const Person& p) {
 std::cout << "Name: " << p.name << ", Age: " << p.age << std::endl;
}

Person createPerson() {
 Person p;
 p.name = "Bob";
 p.age = 30;
 return p;
}

int main() {
 Person p = createPerson();
 printPerson(p);

 return 0;
}

示例代码：

#include <iostream>

struct Person {
    std::string name;
    int age;
};

void printPerson(const Person& p) {
    std::cout << "Name: " << p.name << ", Age: " << p.age << std::endl;
}

Person createPerson() {
    Person p;
    p.name = "Bob";
    p.age = 30;
    return p;
}

int main() {
    Person p = createPerson();
    printPerson(p);

    return 0;
}

类和对象初步

类的定义和成员

类是面向对象编程的基本组成部分，用于封装数据和操作这些数据的方法。类的定义包括类名、成员变量和成员函数。

  1. 定义类：

    • 定义一个简单的类：

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

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }
};

  2. 创建对象：

    • 创建类的实例并访问成员变量和成员函数：

      Person p;
p.name = "Alice";
p.age = 25;
p.printInfo();

示例代码：

#include <iostream>

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

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

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

    return 0;
}

构造函数和析构函数

构造函数用于初始化对象，析构函数用于在对象生命周期结束时清理资源。

  1. 构造函数：

    • 定义一个带参数的构造函数：

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

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

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }
};

  2. 析构函数：

    • 定义析构函数来清理资源：

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

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

 ~Person() {
     std::cout << "Person destroyed" << std::endl;
 }

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }
};

示例代码：

#include <iostream>

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

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

    ~Person() {
        std::cout << "Person destroyed" << std::endl;
    }

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    p.printInfo();

    return 0;
}

成员函数与成员变量

成员函数用于操作对象的成员变量，成员变量用于存储对象的数据。

  1. 成员函数：

    • 定义成员函数来操作成员变量：

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

 void setName(std::string name) {
     this->name = name;
 }

 void setAge(int age) {
     this->age = age;
 }

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }
};

  2. 成员变量：

    • 访问和修改成员变量：

      Person p;
p.setName("Alice");
p.setAge(25);
p.printInfo();

示例代码：

#include <iostream>

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

    void setName(std::string name) {
        this->name = name;
    }

    void setAge(int age) {
        this->age = age;
    }

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p;
    p.setName("Alice");
    p.setAge(25);
    p.printInfo();

    return 0;
}

封装与信息隐藏

封装是面向对象编程中的一个重要概念，通过封装来隐藏对象的内部细节，只暴露必要的接口。信息隐藏通过访问控制符（如public、private、protected）来实现。

  1. 封装：

    • 通过封装来隐藏对象的内部实现细节：

      class Person {
public:
 void setName(std::string name) {
     this->name = name;
 }

 void setAge(int age) {
     this->age = age;
 }

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }

private:
 std::string name;
 int age;
};

  2. 信息隐藏：

    • 使用访问控制符来隐藏成员变量：

      class Person {
public:
 void setName(std::string name) {
     this->name = name;
 }

 void setAge(int age) {
     this->age = age;
 }

 void printInfo() {
     std::cout << "Name: " << name << ", Age: " << age << std::endl;
 }

private:
 std::string name;
 int age;
};

示例代码：

#include <iostream>

class Person {
public:
    void setName(std::string name) {
        this->name = name;
    }

    void setAge(int age) {
        this->age = age;
    }

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }

private:
    std::string name;
    int age;
};

int main() {
    Person p;
    p.setName("Alice");
    p.setAge(25);
    p.printInfo();

    return 0;
}

通过以上步骤，你可以从零开始掌握C++编程的基础知识。从环境搭建到基本语法，再到面向对象编程的核心概念，每一个部分都是学习C++编程所必需的。希望这篇文章对你有所帮助。

点击查看更多内容
发表于 2024.10.23 21:05， 共 111 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

MMTTMM

手记
篇
粉丝
65
获赞与收藏
364

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消