首页手记 C++编程入门教程：从零开始学习C++

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

标签：

C++

概述

本文详细介绍了如何搭建C++编程环境，包括选择合适的IDE和安装编译器GCC的步骤。同时，文章还讲解了如何配置开发环境，以便顺利编写和调试C++程序。此外，文章还涵盖了C++的基础语法、控制流程、函数和面向对象编程等内容，帮助读者全面掌握C++编程技巧。

C++编程环境搭建

在开始学习C++编程之前，需要搭建一个合适的编程环境。本节将介绍如何选择合适的集成开发环境（IDE）以及如何安装和配置编译器GCC。

选择合适的集成开发环境（IDE）

集成开发环境（Integrated Development Environment，简称IDE）是编程的重要工具，它集成了代码编辑器、编译器、调试器等多种功能。C++编程中常用的IDE有很多，如Visual Studio、Code::Blocks、Dev-C++等。对于初学者来说，推荐使用Code::Blocks或Dev-C++，它们提供了友好的用户界面和丰富的功能。

Code::Blocks是一款开源的C/C++ IDE，支持多种编译器。该IDE拥有易于使用的用户界面，并提供了代码自动完成、语法高亮以及调试功能。Code::Blocks适用于Windows、Linux和macOS等操作系统。

Dev-C++是另一款流行的C/C++ IDE，它基于Code::Blocks，但更加专注于Windows平台。尽管Dev-C++的功能相对简单，但它的界面简洁，操作方便，非常适合初学者使用。

安装编译器（如GCC）

编译器是将源代码转换成机器代码的重要工具。选择合适的编译器对学习C++非常重要。GCC（GNU Compiler Collection）是一款广泛使用的开源编译器。以下是安装GCC的步骤：

在Windows上安装GCC

下载并安装MinGW（Minimalist GNU for Windows）。MinGW是一个包含GCC的开发环境，可以在其官方网站或第三方网站上下载。
安装完成后，在命令行界面中输入gcc --version，验证GCC是否安装成功。

在Linux上安装GCC

在Linux上安装GCC非常简单。打开终端，输入以下命令：

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

在macOS上安装GCC

在macOS上，可以通过Homebrew安装GCC。首先，确保已经安装了Homebrew，然后在终端中输入以下命令：

brew install gcc

配置开发环境

安装完IDE和编译器后，需要进行一些必要的配置，使得IDE能够正确地运行和调试C++程序。

配置Code::Blocks

打开Code::Blocks，选择“File” > “New” > “Project”。
在项目向导中选择“Console application”，然后点击“Go”。
为项目起个名字，选择保存路径，然后点击“Next”。
选择编译器（默认是MinGW，如果安装了其他编译器，可以在此处选择），然后点击“Finish”。
在项目文件夹中，找到并打开源代码文件（通常是.cpp文件）。

配置Dev-C++

打开Dev-C++，选择“File” > “New” > “Project”。
在项目向导中选择“Console Application”。
为项目起个名字，选择保存路径，然后点击“Next”。
选择编译器（默认是TDM-GCC），然后点击“Finish”。
在项目文件夹中，找到并打开源代码文件（通常是.cpp文件）。

配置完成后，可以开始编写和调试简单的C++程序了。为了更好地学习C++，建议在IDE中编写一个“Hello, World!”程序，代码如下：

#include <iostream>

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

将上述代码输入到IDE中，然后编译并运行程序。如果成功输出了“Hello, World!”，则说明开发环境已经配置成功。

C++基础语法

学习C++的基础语法是学习C++的重要一步。本节将介绍数据类型和变量、常量和字面量以及运算符。

数据类型和变量

C++是一种静态类型语言，程序中的变量需要预先声明其类型。常见的数据类型包括整型、浮点型、字符型、布尔型等。

基本数据类型

整型：int、short、long、long long。这些类型用于存储整数值。
浮点型：float、double。这些类型用于存储浮点数值。
字符型：char。用于存储单个字符。
布尔型：bool。用于存储逻辑值，即true或false。

声明变量

在C++中，声明变量需要指定变量的类型和名称。例如：

int age;
float price;
char grade;
bool is_student;

初始化变量

声明变量后，可以通过赋值操作符=进行初始化：

int age = 25;
float price = 19.99f;
char grade = 'A';
bool is_student = true;

常量和字面量

常量是指在程序执行期间其值不会改变的变量。在C++中，可以使用const关键字声明常量，也可以使用#define宏定义常量。

常量声明

使用const关键字声明常量：

const int MAX_LENGTH = 100;
const float PI = 3.14159;

字面量

字面量是直接写在代码中的数据。C++支持多种类型的字面量，例如整数字面量、浮点数字面量、字符字面量和字符串字面量等。

整数字面量

整数字面量可以是十进制、八进制或十六进制表示：

int dec = 10;    // 十进制
int oct = 010;   // 八进制
int hex = 0x10;  // 十六进制

浮点数字面量

浮点数字面量可以是十进制或科学计数法表示：

float floatNum = 19.99f;  // 十进制浮点数
double doubleNum = 1.23e10;  // 科学计数法浮点数

字符字面量

字符字面量用单引号包围：

char ch = 'A';

字符串字面量

字符串字面量用双引号包围：

const char* name = "Alice";

运算符

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

算术运算符

算术运算符用于执行基本的数学运算，包括加法+、减法-、乘法*、除法/以及取余%。

int a = 10;
int b = 5;
int sum = a + b;         // 15
int diff = a - b;        // 5
int product = a * b;     // 50
int quotient = a / b;    // 2
int remainder = a % b;   // 0

关系运算符

关系运算符用于比较两个操作数。结果为布尔值true或false。

int x = 10;
int y = 20;
bool isGreater = x > y;       // false
bool isEqual = x == y;        // false
bool isLessOrEqual = x <= y;  // true

逻辑运算符

逻辑运算符用于对布尔表达式进行逻辑运算，包括&&（逻辑与）、||（逻辑或）以及!（逻辑非）。

bool flag1 = true;
bool flag2 = false;

bool resultAnd = flag1 && flag2;  // false
bool resultOr = flag1 || flag2;   // true
bool resultNot = !flag1;          // false

位运算符

位运算符用于对整数的二进制位进行操作，包括按位与&、按位或|、按位异或^、按位取反~、左移<<和右移>>。

int a = 10;  // 二进制为 1010
int b = 5;   // 二进制为 0101

int andResult = a & b;  // 0000 (二进制)
int orResult = a | b;   // 1111 (二进制)
int xorResult = a ^ b;  // 1111 (二进制)
int notResult = ~a;     // 0101 (二进制)
int leftResult = a << 2; // 101000 (二进制)
int rightResult = a >> 1; // 101 (二进制)

C++控制流程

C++程序的执行流程可以通过条件语句和循环语句来控制。本节将介绍条件语句（如if、switch）和循环语句（如for、while、do-while）。

条件语句

条件语句用于根据特定条件执行不同的代码块。

if语句

if语句是最基本的条件语句。它根据条件是否为真来执行代码块。

int age = 18;
if (age >= 18) {
    std::cout << "成年人" << std::endl;
} else {
    std::cout << "未成年人" << std::endl;
}

if-else语句

if-else语句用于在条件为真时执行一个代码块，在条件为假时执行另一个代码块。

int score = 85;
if (score >= 60) {
    std::cout << "及格" << std::endl;
} else {
    std::cout << "不及格" << std::endl;
}

if-else if-else语句

if-else if-else语句用于在多个条件中选择一个满足条件的分支。

int grade = 85;
if (grade >= 90) {
    std::cout << "优秀" << std::endl;
} else if (grade >= 80) {
    std::cout << "良好" << std::endl;
} else if (grade >= 70) {
    std::cout << "及格" << std::endl;
} else {
    std::cout << "不及格" << std::endl;
}

switch语句

switch语句用于根据不同的条件执行不同的代码块。它通常用于多个互斥条件的判断。

int number = 2;
switch (number) {
    case 1:
        std::cout << "数字为1" << std::endl;
        break;
    case 2:
        std::cout << "数字为2" << std::endl;
        break;
    default:
        std::cout << "其他数字" << std::endl;
}

循环语句

循环语句用于重复执行一段代码，直到满足特定条件。

for循环

for循环用于在固定次数内执行代码块。

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

while循环

while循环用于在条件为真时执行代码块。

int count = 0;
while (count < 5) {
    std::cout << "数字：" << count << std::endl;
    count++;
}

do-while循环

do-while循环用于至少执行一次代码块，然后在每次循环结束时检查条件。

int counter = 1;
do {
    std::cout << "数字：" << counter << std::endl;
    counter++;
} while (counter < 5);

C++函数

函数是C++编程的重要组成部分。通过函数，可以将代码模块化，提高代码复用性和可维护性。本节将介绍函数的定义和调用、函数参数和返回值以及内置函数和库函数。

函数定义和调用

函数是执行特定任务的一段代码。函数由函数头和函数体组成。函数头包括函数返回类型、函数名和参数列表。

函数定义

定义函数的基本语法如下：

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

例如，定义一个计算两个整数之和的函数：

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

函数调用

调用函数需要指定函数名和必要的参数。返回值可以根据需要进行存储或直接使用。

int result = add(10, 20);
std::cout << "结果：" << result << std::endl;

函数参数和返回值

函数通过参数传递数据，通过返回值返回结果。参数可以是值传递或引用传递，返回值可以是任何有效的数据类型。

值传递和引用传递

值传递是指将实参的副本传递给形式参数，修改形式参数不会影响实参。引用传递是指将实参的地址传递给形式参数，修改形式参数会改变实参的值。

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

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

int num1 = 10, num2 = 20;
swapByValue(num1, num2);    // num1 和 num2 不变
swapByReference(num1, num2); // num1 和 num2 互换

返回值

函数可以返回任何有效的数据类型，包括基本类型、指针类型、引用类型等。

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

int result = multiply(5, 3);
std::cout << "结果：" << result << std::endl;

内置函数和库函数

C++提供了许多内置函数和库函数，这些函数在不同的情况下会派上用场。

内置函数

C++内置了一些函数，例如输入输出函数std::cin和std::cout，以及数学函数库<cmath>中的函数。

#include <iostream>
#include <cmath>

int main() {
    std::cout << "请输入一个数字：";
    double number;
    std::cin >> number;
    std::cout << "平方根：" << std::sqrt(number) << std::endl;
    return 0;
}

库函数

C++提供了丰富的标准库函数，这些函数位于头文件中。例如，<string>库提供了字符串操作函数，<vector>库提供了动态数组功能。

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::string name = "Alice";
    std::cout << "原名：" << name << std::endl;
    name = name + " Zhang";
    std::cout << "新名：" << name << std::endl;

    std::vector<int> numbers = {1, 2, 3, 4, 5};
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}

C++面向对象编程

面向对象编程（Object-Oriented Programming，简称OOP）是C++的重要特性之一。通过面向对象编程，可以更好地组织和封装代码，提高程序的可读性和可维护性。本节将介绍类和对象、构造函数和析构函数、继承和多态。

类和对象

类是面向对象编程中的基本概念，它是一种用户定义的类型，包含了数据成员和成员函数。对象是类的实例，是一个具体的数据实体。

定义类

定义一个简单的类如下：

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

    void display() {
        std::cout << "姓名：" << name << " 年龄：" << age << std::endl;
    }
};

创建对象

创建类的对象时，需要指定类名和对象名，并根据需要初始化成员变量。

int main() {
    Person person;
    person.name = "Alice";
    person.age = 25;
    person.display();
    return 0;
}

构造函数和析构函数

构造函数和析构函数是类的特殊成员函数，它们在对象创建和销毁时被自动调用。构造函数用于初始化对象，析构函数用于清理资源。

构造函数

构造函数可以有0个或多个参数，用于初始化对象的成员变量。构造函数的名字与类名相同，没有返回类型。

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

    Person(std::string name, int age) {
        this->name = name;
        this->age = age;
    }

    void display() {
        std::cout << "姓名：" << name << " 年龄：" << age << std::endl;
    }
};

析构函数

析构函数用于清理对象占用的资源，通常用于释放动态分配的内存。析构函数的名字是类名加上~符号，没有返回类型。

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

    Person(std::string name, int age) {
        this->name = name;
        this->age = age;
        id = new int; // 动态分配内存
        *id = 123;
    }

    ~Person() {
        delete id; // 释放内存
    }

    void display() {
        std::cout << "姓名：" << name << " 年龄：" << age << " ID：" << *id << std::endl;
    }
};

继承和多态

继承是一种机制，允许一个类继承另一个类的属性和方法。多态允许对象以统一的方式执行不同的操作。

继承

通过继承，可以创建一个新的类，该类继承了另一个类的所有成员变量和成员函数。基类（父类）可以被一个或多个派生类（子类）继承。

class Animal {
public:
    std::string name;

    void display() {
        std::cout << "动物：" << name << std::endl;
    }
};

class Dog : public Animal {
public:
    void display() {
        std::cout << "狗：" << name << std::endl;
    }
};

多态

多态允许通过基类指针或引用，调用派生类中定义的不同方法。这使得程序更具灵活性和扩展性。

class Animal {
public:
    std::string name;

    virtual void display() {
        std::cout << "动物：" << name << std::endl;
    }
};

class Dog : public Animal {
public:
    void display() {
        std::cout << "狗：" << name << std::endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->display();  // 输出：狗：狗
    return 0;
}

C++编程实践

通过学习基础语法、控制流程、函数和面向对象编程，可以编写简单的程序。本节将通过一些小项目实践，加深对C++的理解。此外，还将介绍一些代码调试技巧。

小项目实践

计算器

编写一个简单的计算器程序，可以进行加、减、乘、除等基本运算。

#include <iostream>

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) {
    return a / b;
}

int main() {
    int num1, num2;
    std::cout << "请输入第一个数字：";
    std::cin >> num1;
    std::cout << "请输入第二个数字：";
    std::cin >> num2;

    std::cout << "加法：" << add(num1, num2) << std::endl;
    std::cout << "减法：" << subtract(num1, num2) << std::endl;
    std::cout << "乘法：" << multiply(num1, num2) << std::endl;
    std::cout << "除法：" << divide(num1, num2) << std::endl;

    return 0;
}

简单数据结构

实现一个简单的链表，可以插入、删除和遍历元素。

#include <iostream>

struct Node {
    int data;
    Node* next;

    Node(int val) {
        data = val;
        next = nullptr;
    }
};

class LinkedList {
public:
    Node* head;

    LinkedList() {
        head = nullptr;
    }

    void insert(int val) {
        Node* newNode = new Node(val);
        newNode->next = head;
        head = newNode;
    }

    void remove(int val) {
        Node* current = head;
        Node* prev = nullptr;

        while (current) {
            if (current->data == val) {
                if (prev) {
                    prev->next = current->next;
                } else {
                    head = current->next;
                }
                delete current;
                return;
            }
            prev = current;
            current = current->next;
        }
    }

    void display() {
        Node* current = head;
        while (current) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    LinkedList list;
    list.insert(1);
    list.insert(2);
    list.insert(3);
    list.display();  // 输出：3 2 1
    list.remove(2);
    list.display();  // 输出：3 1
    return 0;
}

代码调试技巧

调试是编程的重要环节，通过调试可以发现和解决问题。以下是一些常用的调试技巧：

断点调试

在代码中设置断点，运行到断点时暂停程序，观察变量的值。

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    int z = x + y;
    std::cout << "结果：" << z << std::endl;
    return 0;
}

单步执行

一步一步地执行代码，查看每一步的执行情况和变量的值。

跟踪调用

跟踪函数调用，查看函数调用顺序和参数值。

#include <iostream>

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

int main() {
    int a = 5;
    int b = 7;
    int result = add(a, b);
    std::cout << "结果：" << result << std::endl;
    return 0;
}

日志输出

在关键位置插入日志输出语句，输出变量的值或程序运行状态。

通过实践和调试，可以更好地理解和掌握C++编程。希望本节内容能够帮助读者更好地进行C++编程实践。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕神8447489

手记
篇

粉丝

174

获赞与收藏

957

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11957 246

后端通用面试教程

41个小节 31416 348

网络编程入门教程

20个小节 12873 242

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空