为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 C++基础语法入门教程

C++基础语法入门教程

标签：
C++
概述

本文详细介绍了C++基础语法入门，包括注释、数据类型、变量与常量、运算符、输入输出、流程控制、函数与作用域、数组与字符串以及面向对象编程基础。文章从开发环境搭建开始，逐步引导读者理解C++语言的核心概念和编程技巧。通过这些内容，读者可以快速掌握C++编程的基本技能。

C++简介与开发环境搭建
C++语言简介

C++是一种通用、编译型、面向对象的编程语言，由Bjarne Stroustrup于1979年开始设计。C++是C语言的超集，继承了C语言的简洁高效，并在此基础上增加了面向对象的特性。C++被广泛应用于系统软件、应用软件、游戏开发、嵌入式系统等领域。

C++拥有丰富的库函数，可以进行高效的内存管理，支持泛型编程、模板等高级特性。C++的面向对象特性使得程序模块化、可维护性更强。C++语言的灵活性也使得它在不同领域的应用都非常广泛。

开发工具选择

在进行C++开发之前，选择合适的开发工具是非常重要的。常见的C++开发工具包括Visual Studio、Code::Blocks、CLion等。其中，Code::Blocks是一个开源的跨平台IDE，适合初学者使用；而CLion则是JetBrains出品的一款专业C++开发环境，支持智能感知和代码重构。

对于Windows用户，推荐使用Visual Studio Community版（免费版），它拥有强大的代码编辑、调试、版本控制等功能。对于Linux用户，可以使用Code::Blocks或CLion。如果你是Mac用户，可以使用Xcode。此外，还有Code::Blocks，一款非常流行的开源IDE，支持多种操作系统，适合初学者使用。

使用Code::Blocks搭建开发环境

Code::Blocks的下载与安装步骤如下：

  1. 访问Code::Blocks官方网站，下载最新版本。
  2. 打开下载的文件，根据提示安装Code::Blocks。
  3. 打开安装后的Code::Blocks，创建一个新项目，选择“Console application”，命名为cpp_hello，点击“Next”。在弹出的窗口中选择项目的保存位置，点击“Finish”。
  4. 在新创建的项目中，右键点击解决方案资源管理器中的cpp_hello，选择“新建” > “源文件(.cpp)”并命名为main.cpp，点击“确定”。接下来，在main.cpp中编写第一个C++程序：
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}
  1. 编译并运行程序，点击工具栏上的“编译”按钮（锤子图标），或按F7。如果程序没有错误，将弹出一个窗口显示“Hello, World!”。如果程序有错误，Code::Blocks会给出错误提示。

使用CLion搭建开发环境

CLion的下载与安装步骤如下：

  1. 访问JetBrains官方网站，下载CLion社区版。
  2. 打开下载的文件，根据提示安装CLion。
  3. 打开安装后的CLion，创建一个新项目，选择“C++ Console Application”，命名为cpp_hello，点击“Next”。在弹出的窗口中选择项目的保存位置，点击“Finish”。
  4. 在新创建的项目中，右键点击解决方案资源管理器中的cpp_hello，选择“新建文件”，命名为main.cpp，点击“确定”。接下来，在main.cpp中编写第一个C++程序：
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}
  1. 编译并运行程序，点击工具栏上的“运行”按钮（绿色三角形），或按Ctrl + Shift + F10。如果程序没有错误，将弹出一个窗口显示“Hello, World!”。如果程序有错误，CLion会给出错误提示。
开发环境搭建步骤

以下是使用Visual Studio Community搭建C++开发环境的步骤：

  1. 下载安装Visual Studio Community

    访问Visual Studio官方网站，下载Visual Studio Community版。

    https://visualstudio.microsoft.com/zh-hans/downloads/

    打开下载的文件，根据提示安装Visual Studio Community。安装时可以选择“使用自定义设置安装”，然后在“工作负载”中选择“使用C++的桌面开发”。安装完成后，打开Visual Studio。

  2. 创建C++项目

    打开Visual Studio，点击“创建新项目”。在新窗口中选择“空项目”，命名为cpp_hello，点击“下一步”。在弹出的窗口中选择项目的保存位置，点击“创建”。创建完成后，项目将出现在解决方案资源管理器中。

  3. 编写第一个C++程序

    右键点击解决方案资源管理器中的项目名cpp_hello，选择“添加” > “新项”，选择“源文件(.cpp)”并命名为main.cpp，点击“添加”。接下来，在main.cpp中编写第一个C++程序：

    #include <iostream>

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

  4. 编译和运行程序

    编译程序，点击工具栏上的“开始调试”按钮（绿色的三角形），或者按Ctrl + F5组合键。如果程序没有错误，将弹出一个窗口显示“Hello, World!”。如果程序有错误，Visual Studio会给出错误提示。

C++基本语法
注释

在C++中，注释有两种形式，单行注释和多行注释，用于解释代码的功能和逻辑。

  • 单行注释：使用//标记单行注释，从//开始到该行结束的所有内容都会被忽略。

    // 这是一个单行注释
  • 多行注释：使用/* ... */标记多行注释，从/*开始，*/结束的所有内容都会被忽略。 
    /* 这是一个多行注释
 可以写多行
 */
数据类型

在C++中，变量的类型决定了变量如何存储值，包括它的大小、如何解释和操作这个值。C++提供了多种数据类型，可以分为基本数据类型（整型、浮点型、字符型和布尔型）和构造数据类型（数组、指针、结构体等）。

基本数据类型

  • 整型：

    int main() {
  int a = 10;  // 整型
  short b = 5; // 短整型
  long c = 10000; // 长整型
  long long d = 10000000000; // 长长整型
  return 0;
}

  • 浮点型：

    int main() {
  float f1 = 3.14f;  // 单精度浮点型
  double f2 = 3.14; // 双精度浮点型
  return 0;
}

  • 字符型：

    int main() {
  char c = 'A';  // 字符类型
  wchar_t wc = L'W'; // 宽字符类型
  return 0;
}
  • 布尔型： 
    int main() {
  bool flag = true;  // 布尔类型
  return 0;
}

构造数据类型

  • 数组：

    int main() {
  int arr[5] = {1, 2, 3, 4, 5};  // 整型数组
  char str[] = "Hello";  // 字符数组
  return 0;
}
  • 指针： 
    int main() {
  int a = 10;
  int *p = &a;  // 指针的声明和初始化
  *p = 20;  // 通过指针修改a的值
  return 0;
}
变量与常量

变量定义

变量是程序中存储数据的内存位置，可以通过变量名访问和修改它们的值。变量定义时需要指定类型和名称。

int main() {
    int num1;  // 定义整型变量num1
    float num2 = 3.14;  // 定义浮点型变量num2并初始化
    char letter = 'A';  // 定义字符型变量letter并初始化
    return 0;
}

常量

常量是具有固定值的量，其值一旦被初始化，就不会改变。C++中可以通过const关键字定义常量。

int main() {
    const int MAX = 100;  // 定义整型常量MAX
    const float PI = 3.14;  // 定义浮点型常量PI
    return 0;
}
运算符

C++支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和自增自减运算符等。

算术运算符

算术运算符用于执行基本的数学运算。

int main() {
    int a = 10;
    int b = 5;
    int sum = a + b;  // 加法
    int diff = a - b; // 减法
    int prod = a * b; // 乘法
    int quot = a / b; // 除法
    int rem = a % b;  // 取余
    return 0;
}

关系运算符

关系运算符用于比较两个操作数，返回布尔值。

int main() {
    int a = 10;
    int b = 5;
    bool result1 = a > b;  // 大于
    bool result2 = a < b;  // 小于
    bool result3 = a == b; // 等于
    bool result4 = a != b; // 不等于
    return 0;
}

逻辑运算符

逻辑运算符用于对布尔值进行逻辑运算。

int main() {
    bool a = true;
    bool b = false;
    bool result1 = a && b;  // 逻辑与
    bool result2 = a || b;  // 逻辑或
    bool result3 = !a;      // 逻辑非
    return 0;
}

位运算符

位运算符用于对整数的二进制位进行操作。

int main() {
    int a = 6;  // 二进制为0110
    int b = 3;  // 二进制为0011
    int andResult = a & b;  // 按位与
    int orResult = a | b;   // 按位或
    int xorResult = a ^ b;  // 按位异或
    int shiftResult = a << 1;  // 左移一位
    return 0;
}

赋值运算符

赋值运算符用于给变量赋值。

int main() {
    int a;
    a = 10;  // 直接赋值
    a += 5;  // 等价于 a = a + 5
    a -= 5;  // 等价于 a = a - 5
    a *= 5;  // 等价于 a = a * 5
    a /= 5;  // 等价于 a = a / 5
    a %= 5;  // 等价于 a = a % 5
    return 0;
}

自增自减运算符

自增自减运算符用于增加或减少变量的值。

int main() {
    int a = 5;
    int b = a++;  // 后置自增，b=5，a=6
    int c = ++a;  // 前置自增，c=7，a=7
    int d = a--;  // 后置自减，d=7，a=6
    int e = --a;  // 前置自减，e=5，a=5
    return 0;
}
输入输出

在C++中，输入输出操作通常使用标准库中的iostream，它封装了输入输出流对象，如cin和cout。

输入

cin用于从标准输入流读取数据，例如键盘输入。cin可以读取各种类型的数据，如整数、浮点数、字符等。

int main() {
    int a;
    float b;
    char c;
    std::cout << "请输入一个整数：";
    std::cin >> a;
    std::cout << "请输入一个浮点数：";
    std::cin >> b;
    std::cout << "请输入一个字符：";
    std::cin >> c;
    return 0;
}

输出

cout用于向标准输出流输出数据，例如显示器。cout可以输出各种类型的数据，如整数、浮点数、字符串等。

int main() {
    int a = 10;
    float b = 3.14;
    char c = 'A';
    std::cout << "整数：" << a << std::endl;
    std::cout << "浮点数：" << b << std::endl;
    std::cout << "字符：" << c << std::endl;
    return 0;
}
文件输入输出

使用fstream库可以进行文件的读写操作。

#include <fstream>
#include <iostream>

int main() {
    std::ofstream file("output.txt");
    file << "Hello, World!" << std::endl;
    file.close();

    std::ifstream input("output.txt");
    std::string line;
    while (std::getline(input, line)) {
        std::cout << line << std::endl;
    }
    input.close();
    return 0;
}
C++流程控制
条件语句

条件语句用于控制程序的执行流程，根据条件的真假来执行不同的代码块。C++中的条件语句包括if语句和switch语句。

if语句

if语句是最基本的条件语句，根据条件判断是否执行相应的代码块。

int main() {
    int a = 10;
    if (a > 5) {
        std::cout << "a大于5" << std::endl;
    } else {
        std::cout << "a不大于5" << std::endl;
    }
    return 0;
}

if-else语句

if-else语句用于判断多个条件。

int main() {
    int a = 10;
    int b = 5;
    if (a > b) {
        std::cout << "a大于b" << std::endl;
    } else if (a < b) {
        std::cout << "a小于b" << std::endl;
    } else {
        std::cout << "a等于b" << std::endl;
    }
    return 0;
}

switch语句

switch语句用于根据变量的值执行不同的代码块，通常用于多个分支的选择。

int main() {
    int choice = 1;
    switch (choice) {
        case 1:
            std::cout << "选择了1" << std::endl;
            break;
        case 2:
            std::cout << "选择了2" << std::endl;
            break;
        case 3:
            std::cout << "选择了3" << std::endl;
            break;
        default:
            std::cout << "其他选择" << std::endl;
    }
    return 0;
}
循环语句

循环语句用于重复执行一段代码，直到满足特定的条件为止。C++中的循环语句包括for循环、while循环和do-while循环。

for循环

for循环用于执行特定次数的循环。

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

while循环

while循环用于在满足条件时执行循环体。

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

do-while循环

do-while循环与while循环类似，不同之处在于do-while循环至少会执行一次循环体。

int main() {
    int i = 0;
    do {
        std::cout << "i = " << i << std::endl;
        i++;
    } while (i < 5);
    return 0;
}
嵌套循环

嵌套循环用于在循环体内嵌套另一个循环，例如，实现多层循环结构。

int main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << "i = " << i << ", j = " << j << std::endl;
        }
    }
    return 0;
}
跳转语句

跳转语句用于改变程序的执行流程，包括break、continue和goto。

break语句

break语句用于提前退出循环体。

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

continue语句

continue语句用于跳过循环体中的剩余代码，并继续下一个循环。

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

goto语句

goto语句用于无条件跳转到指定标号处。

int main() {
    int i = 0;
    label:
    if (i == 5) {
        goto end;
    }
    i++;
    goto label;
    end:
    std::cout << "i = " << i << std::endl;
    return 0;
}
C++函数与作用域
函数定义与调用

函数是一段可重用的代码块，用于执行特定的任务。函数可以接受参数，也可以返回结果。

函数定义

函数定义包括函数名、返回类型、参数列表和函数体。

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

函数调用

函数调用是通过函数名来执行函数体内的代码，并传递必要的参数。

int main() {
    int result = sum(3, 4);
    std::cout << "结果：" << result << std::endl;
    return 0;
}

返回值

函数可以通过return语句返回一个值。

int main() {
    int a = 3;
    int b = 4;
    int result = sum(a, b);
    std::cout << "结果：" << result << std::endl;
    return 0;
}
参数传递

C++中的参数传递方式有两种：传值和传引用。

传值

传值是将实参的值复制给形参。

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

传引用

传引用是直接将实参的地址传递给形参。

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

int main() {
    int a = 10;
    int result = sum(a, 5);
    std::cout << "结果：" << result << std::endl;
    return 0;
}
作用域规则

作用域是指变量或函数的可见范围。在C++中，作用域可以分为全局作用域和局部作用域。

全局作用域

全局作用域是指变量或函数在整个程序中都是可见的。

int global = 10;

int main() {
    std::cout << "全局变量：" << global << std::endl;
    return 0;
}

局部作用域

局部作用域是指变量或函数只在特定的作用域中是可见的。

int main() {
    int local = 20;
    {
        int local = 30;
        std::cout << "局部变量：" << local << std::endl;
    }
    std::cout << "局部变量：" << local << std::endl;
    return 0;
}

函数重载

函数重载是指在同一个作用域内，可以有多个同名函数，但它们的参数列表不同。

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

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

int main() {
    int result1 = sum(3, 4);
    double result2 = sum(3.5, 4.5);
    std::cout << "结果1：" << result1 << std::endl;
    std::cout << "结果2：" << result2 << std::endl;
    return 0;
}

内联函数

内联函数是一种特殊的函数，可以在函数调用时直接展开，提高程序的执行效率。

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

int main() {
    int result = sum(3, 4);
    std::cout << "结果：" << result << std::endl;
    return 0;
}

模板函数

模板函数是一种通用的函数，可以处理不同类型的参数。

template <typename T>
T sum(T a, T b) {
    return a + b;
}

int main() {
    int result1 = sum(3, 4);
    double result2 = sum(3.5, 4.5);
    std::cout << "结果1：" << result1 << std::endl;
    std::cout << "结果2：" << result2 << std::endl;
    return 0;
}
C++数组与字符串
数组定义与使用

数组是一种数据结构，用于存储相同类型的一组数据。它可以是一维数组或多维数组。

一维数组

一维数组是最基本的数组类型，用于存储线性排列的数据。

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;
}

多维数组

多维数组用于存储二维或多维的数据。

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++提供了多种字符串处理函数，如strlen、strcpy、strcat等。

strlen

strlen函数用于获取字符串长度。

#include <cstring>
#include <iostream>

int main() {
    char str[] = "Hello";
    int length = strlen(str);
    std::cout << "字符串长度：" << length << std::endl;
    return 0;
}

strcpy

strcpy函数用于复制字符串。

#include <cstring>

int main() {
    char src[] = "Hello";
    char dest[10];
    strcpy(dest, src);
    std::cout << "源字符串：" << src << std::endl;
    std::cout << "目标字符串：" << dest << std::endl;
    return 0;
}

strcat

strcat函数用于连接两个字符串。

#include <cstring>

int main() {
    char str1[20] = "Hello";
    char str2[] = "World";
    strcat(str1, str2);
    std::cout << "连接后的字符串：" << str1 << std::endl;
    return 0;
}
数组与字符串的应用实例

下面是一个简单的应用实例，使用数组和字符串处理函数来统计字符串中的字符数。

#include <cstring>
#include <iostream>

int main() {
    char str[] = "Hello, World!";
    int length = strlen(str);
    std::cout << "字符串长度：" << length << std::endl;
    return 0;
}
C++面向对象编程基础
类与对象

在C++中，面向对象编程是通过类和对象来实现的。类是一个模板，定义了对象的属性和行为；对象是类的实例，拥有具体的属性值。

类定义

类定义包括类名、成员变量和成员函数。

class Person {
public:
    std::string name;
    int age;
    void introduce() {
        std::cout << "姓名：" << name << "，年龄：" << age << std::endl;
    }
};

对象创建

对象是通过类创建的实例，并通过构造函数初始化。

int main() {
    Person person;
    person.name = "张三";
    person.age = 25;
    person.introduce();
    return 0;
}
成员函数与变量

成员函数是定义在类内的函数，用于实现类的功能；成员变量是定义在类内的变量，用于存储对象的数据。

class Person {
public:
    std::string name;
    int age;
    void introduce() {
        std::cout << "姓名：" << name << "，年龄：" << age << std::endl;
    }
    void setName(std::string name) {
        this->name = name;
    }
};

成员变量

成员变量是定义在类内的变量，用于存储对象的数据。

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

成员函数

成员函数是定义在类内的函数，用于实现类的功能。

class Person {
public:
    std::string name;
    int age;
    void introduce() {
        std::cout << "姓名：" << name << "，年龄：" << age << std::endl;
    }
};
构造与析构函数

构造函数是在创建对象时被调用的函数，用于初始化对象的成员变量；析构函数是在对象被销毁时被调用的函数，用于清理资源。

构造函数

构造函数是定义在类内的特殊函数，用于初始化对象的成员变量。

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

析构函数

析构函数是定义在类内的特殊函数，用于清理资源。

class Person {
public:
    std::string name;
    int age;
    ~Person() {
        std::cout << "析构函数被调用" << std::endl;
    }
};

构造函数调用示例

int main() {
    Person person("张三", 25);
    person.introduce();
    return 0;
}

析构函数调用示例

int main() {
    {
        Person person("张三", 25);
        person.introduce();
    }
    return 0;
}
继承与多态简介

继承是一种机制，允许一个类继承另一个类的属性和行为；多态是一种机制，允许一个接口表示不同的类型。

继承

继承是一种机制，允许一个类继承另一个类的属性和行为。

class Person {
public:
    std::string name;
    int age;
    void introduce() {
        std::cout << "姓名：" << name << "，年龄：" << age << std::endl;
    }
};

class Student : public Person {
public:
    int grade;
    void introduce() {
        std::cout << "姓名：" << name << "，年龄：" << age << "，年级：" << grade << std::endl;
    }
};

多态

多态是一种机制，允许一个接口表示不同的类型。

class Person {
public:
    virtual void introduce() = 0;
};

class Student : public Person {
public:
    int grade;
    void introduce() override {
        std::cout << "我是学生" << std::endl;
    }
};

class Teacher : public Person {
public:
    void introduce() override {
        std::cout << "我是老师" << std::endl;
    }
};

继承和多态应用实例

int main() {
    Person *p;
    Student student;
    Teacher teacher;
    p = &student;
    p->introduce();
    p = &teacher;
    p->introduce();
    return 0;
}

通过上述内容，你已经掌握了C++语言的基础语法和面向对象编程的基本概念。你可以继续学习更高级的主题，如泛型编程、模板、STL等，以进一步提高你的编程技能。如果你想继续学习C++，可以考虑访问慕课网。

点击查看更多内容
发表于 2024.10.25 17:53， 共 108 人浏览

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

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

慕莱坞森

手记
篇
粉丝
36
获赞与收藏
146

关注作者，订阅最新文章

阅读免费教程

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

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
微信客服

购课补贴
联系客服咨询优惠详情

 帮助反馈 APP下载

慕课网APP
您的移动学习伙伴

 公众号

扫描二维码
关注慕课网微信公众号

举报

0/150
提交
取消