C++基础语法学习教程

概述

本文介绍了C++基础语法学习的相关内容，包括开发环境搭建、基本语法如变量和常量、数据类型以及运算符的使用。此外，文章还详细讲解了流程控制、函数与作用域、数组与指针、以及结构体和类的初步概念。通过这些内容，读者可以全面了解和掌握C++基础语法学习。

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

C++语言简介

C++是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的程序设计语言。其设计目标是提供对硬件的低级访问（如直接的内存访问和高效率的代码执行），同时具有高级语言的特性（如类、模板等）。C++是在C语言的基础上发展起来的，它保留了C语言的所有特性，并引入了面向对象的编程特性，如类和对象，以及多态等概念。

C++标准版本包括C++98、C++11、C++14等，每个版本都增加了新的语言特性和库功能。C++11引入了如auto类型推导、lambda表达式、范围for循环等新特性，极大地提升了编程效率和代码的可读性。

开发工具选择与安装

对于初学者而言，选择合适的开发工具非常重要。以下是一些流行的C++开发工具：

1. Visual Studio Code (VS Code)

   • VS Code是一款功能强大的源代码编辑器，支持多种编程语言，包括C++。它支持丰富的插件，可以帮助你提高开发效率。
   • 安装VS Code: 访问其官方网站https://code.visualstudio.com/，下载适用于你操作系统的版本，然后按照提示安装。
   • 配置C++扩展和库: 安装C++插件，如Microsoft的C++插件。该插件提供了智能感知、语法高亮和调试工具。如果需要使用特定的库，可以在项目中添加相应的依赖项。

2. Visual Studio

   • Visual Studio是Microsoft提供的一款集成开发环境（IDE），适用于Windows平台。它不仅支持C++开发，还支持其他多种语言。
   • 安装Visual Studio: 访问其官方网站https://visualstudio.microsoft.com/，下载并安装适用于你的开发需求的版本。
   • 创建C++项目: 在Visual Studio中，可以通过“创建新项目”选项选择C++项目模板，根据提示完成项目创建。

3. Code::Blocks

   • Code::Blocks是一个开源的跨平台集成开发环境，支持多种编程语言，包括C++。它拥有用户友好的界面和丰富的插件支持。
   • 安装Code::Blocks: 访问其官方网站https://www.codeblocks.org/，根据你的操作系统下载并安装。
4. CLion
   • CLion是JetBrains公司开发的一款专为C++编程设计的IDE，支持多种操作系统。它提供了智能的代码助手、强大的重构工具和高效的代码分析。
   • 安装CLion: 访问其官方网站https://www.jetbrains.com/clion/，下载并安装。

编写第一个C++程序

编写第一个C++程序是一个很好的开始。下面是一个简单的"Hello, World!"程序：

#include <iostream>

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

1. 创建新项目

   • 使用你选择的开发工具（例如Visual Studio Code），创建一个新的C++项目。
   • 创建一个新的文件，文件名为main.cpp。

2. 编写代码

   • 将上述"Hello, World!"代码粘贴到main.cpp文件中。
3. 编译和运行
   • 在开发工具中，找到编译和运行的选项。
   • 例如，在VS Code中，你可以使用CMake或直接通过命令行编译和运行程序。在终端中，输入以下命令：

     g++ main.cpp -o hello_world
     ./hello_world

   • 在Visual Studio中，点击工具栏上的"开始调试"按钮，或者使用快捷键F5。

通过上述步骤，你应该能够在开发工具中成功编译并运行第一个C++程序。此程序将输出"Hello, World!"到控制台。

基本语法介绍

变量与常量

在C++中，变量用于存储数据，常量则是固定的值，其值在程序运行过程中不能被改变。变量和常量的类型决定了它们可以存储的数据类型。

变量定义

定义变量时需指定其类型和名称。以下是一些示例：

int myInt;   // 定义一个整型变量
float myFloat;  // 定义一个浮点型变量
char myChar;  // 定义一个字符型变量
bool myBool;  // 定义一个布尔型变量

初始化变量

在定义变量的同时，可以为其初始化：

int myInt = 10;  // 初始化整型变量
float myFloat = 3.14f;  // 初始化浮点型变量
char myChar = 'A';  // 初始化字符型变量
bool myBool = true;  // 初始化布尔型变量

常量定义

常量使用const关键字来定义，一旦初始化后，其值不能被更改：

const int myConstInt = 100;
const float myConstFloat = 3.14f;
const char myConstChar = 'B';
const bool myConstBool = false;

const关键字在引用和指针中的使用

int a = 10;
const int &ref = a;  // 引用常量
const int *p = &a;   // 指针常量

数据类型

C++提供了多种数据类型，每种类型都有特定的用途和范围。以下是常见的几种基本数据类型：

1. 整型

   • int: 通常用来表示整数，占用4个字节。
   • short: 短整型，占用2个字节。
   • long: 长整型，占用4或8个字节（依赖于编译器和平台）。
   • long long: 长长整型，占用8个字节。

2. 浮点型

   • float: 单精度浮点数，占用4个字节。
   • double: 双精度浮点数，占用8个字节。
   • long double: 扩展精度浮点数，占用8或16个字节（依赖于编译器和平台）。

3. 字符型

   • char: 字符类型，占用1个字节。
4. 布尔型
   • bool: 布尔类型，占用1个字节，取值为true或false。

运算符及其使用

运算符是C++中执行特定运算的符号。常用的运算符包括算术运算符、关系运算符、逻辑运算符等。

算术运算符

算术运算符用于执行加法、减法、乘法、除法和取模等操作：

int a = 10;
int b = 5;
int sum = a + b;  // 加法
int difference = a - b;  // 减法
int product = a * b;  // 乘法
int quotient = a / b;  // 除法
int remainder = a % b;  // 取模

关系运算符

关系运算符用于比较两个操作数之间的关系，结果为布尔值true或false：

int x = 10;
int y = 5;

bool isGreater = x > y;  // 大于
bool isLess = x < y;  // 小于
bool isEqual = x == y;  // 等于
bool isNotEqual = x != y;  // 不等于
bool isGreaterOrEqual = x >= y;  // 大于等于
bool isLessOrEqual = x <= y;  // 小于等于

逻辑运算符

逻辑运算符用于执行逻辑操作，如与、或和非操作：

bool a = true;
bool b = false;

bool andResult = a && b;  // 逻辑与
bool orResult = a || b;  // 逻辑或
bool notResult = !a;  // 逻辑非

switch语句的使用示例

int num = 2;

switch (num) {
    case 1:
        std::cout << "Number is 1." << std::endl;
        break;
    case 2:
        std::cout << "Number is 2." << std::endl;
        break;
    case 3:
        std::cout << "Number is 3." << std::endl;
        break;
    default:
        std::cout << "Number is not 1, 2, or 3." << std::endl;
}

通过上述示例代码，你可以更好地理解变量、常量、数据类型以及各种运算符的使用。

流程控制

条件语句（if, switch）

条件语句用于基于某种条件执行不同的代码路径。C++中主要使用if语句和switch语句来实现。

if语句

if语句是最基本的条件语句，其基本格式如下：

if (condition) {
    // 如果条件为真，则执行此代码块
}

可以使用else关键字结合if语句，根据条件选择不同的代码路径：

int age = 20;

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

if-else if-else语句

可以使用else if进行多重条件判断：

int score = 85;

if (score >= 90) {
    std::cout << "Excellent!" << std::endl;
} else if (score >= 80) {
    std::cout << "Good!" << std::endl;
} else if (score >= 70) {
    std::cout << "Average." << std::endl;
} else {
    std::cout << "Below average." << std::endl;
}

switch语句

switch语句用于根据变量的值执行多个分支中的一个。其基本格式如下：

switch (expression) {
    case value1:
        // 当expression等于value1时执行
        break;
    case value2:
        // 当expression等于value2时执行
        break;
    default:
        // 当expression不等于任何case时执行
}

示例代码：

int num = 2;

switch (num) {
    case 1:
        std::cout << "Number is 1." << std::endl;
        break;
    case 2:
        std::cout << "Number is 2." << std::endl;
        break;
    case 3:
        std::cout << "Number is 3." << std::endl;
        break;
    default:
        std::cout << "Number is not 1, 2, or 3." << std::endl;
}

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

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

for循环

for循环通常用于已知迭代次数的情况：

for (初始化; 条件; 每次迭代后的操作) {
    // 循环体
}

示例代码：

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

while循环

while循环用于当条件为真时重复执行代码：

while (条件) {
    // 循环体
}

示例代码：

int count = 0;

while (count < 5) {
    std::cout << "Count: " << count << std::endl;
    count++;
}

do-while循环

do-while循环用于至少执行一次循环体，然后检查条件是否满足继续执行：

do {
    // 循环体
} while (条件);

示例代码：

int count = 0;

do {
    std::cout << "Count: " << count << std::endl;
    count++;
} while (count < 5);

跳转语句（break, continue）

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

break语句

break语句用于立即退出循环或switch语句：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // 退出循环
    }
    std::cout << "i: " << i << std::endl;
}

continue语句

continue语句用于跳过当前循环的剩余部分，直接开始下一次迭代：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;  // 跳过剩余循环体
    }
    std::cout << "i: " << i << std::endl;
}

通过上述示例代码，你可以更好地理解条件语句和循环语句的工作原理。

函数与作用域

函数定义与调用

函数是C++中执行特定任务的代码块。每个函数都有一个名称，可以通过函数名调用执行。函数可以返回值也可以不返回值。

函数定义

函数定义包括函数名称、返回类型、参数列表和函数体。函数体包含执行特定任务的代码。以下是一个简单函数的定义示例：

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

int add(int a, int b)定义了一个名为add的函数，它有两个整型参数a和b，返回一个整型值。

函数调用

在代码中，可以通过函数名称和参数调用函数。如下所示：

#include <iostream>

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

int main() {
    int result = add(3, 5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

函数参数与返回值

函数参数用于传递数据给函数，而返回值则将结果从函数返回到调用者。

参数传递

函数参数可以是基本类型（如整型、浮点型等）或复杂类型（如结构体、类等）。参数传递有两种常见方式：值传递和引用传递。

• 值传递

void setValue(int a) {
    a = 10;
}

int main() {
    int value = 5;
    setValue(value);
    std::cout << "Value: " << value << std::endl;  // 输出5，未改变
    return 0;
}

• 引用传递

void setReference(int &a) {
    a = 10;
}

int main() {
    int value = 5;
    setReference(value);
    std::cout << "Value: " << value << std::endl;  // 输出10，已改变
    return 0;
}

返回值

函数可以返回一个值或多个值。对于返回单个值的函数，可以使用return语句返回该值。对于返回多个值，可以使用引用或指针传递参数。

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

int main() {
    int result = add(3, 5);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

全局变量与局部变量

变量的作用域决定了它可以在代码中的哪些部分被访问。C++中，变量可以是全局变量或局部变量。

全局变量

全局变量在所有函数之外定义，在程序的任何地方都可以访问。它们通常定义在文件的顶部。

#include <iostream>

int globalVar = 100;  // 全局变量

void printGlobal() {
    std::cout << "Global variable: " << globalVar << std::endl;
}

int main() {
    printGlobal();
    return 0;
}

局部变量

局部变量定义在函数内部，在函数外部不可访问。局部变量只能在定义它们的函数内部使用。

#include <iostream>

void printLocal() {
    int localVar = 50;  // 局部变量
    std::cout << "Local variable: " << localVar << std::endl;
}

int main() {
    printLocal();
    // std::cout << "Local variable: " << localVar << std::endl;  // 错误：localVar在main()中不可访问
    return 0;
}

静态成员变量与成员函数

静态成员变量和静态成员函数在类的所有实例之间共享。静态成员函数可以访问静态成员变量。

#include <iostream>

class MyClass {
public:
    static int count;
    MyClass() {
        count++;
    }
    static void printCount() {
        std::cout << "Count: " << count << std::endl;
    }
};

int MyClass::count = 0;

int main() {
    MyClass obj1;
    MyClass obj2;
    MyClass::printCount();  // 输出2
    return 0;
}

通过上述示例代码，你可以更好地理解函数定义、参数传递、返回值以及全局变量和局部变量的作用域。

数组与指针

数组的定义与使用

数组是一种数据结构，用于存储相同类型的多个元素。数组中的每个元素可以通过索引访问和修改。

定义数组

数组的定义包括数组类型、数组名称和数组长度。数组元素从0开始索引。

#include <iostream>

int main() {
    int numbers[5];  // 定义一个整型数组，长度为5
    for (int i = 0; i < 5; i++) {
        numbers[i] = i;  // 赋值
    }
    for (int i = 0; i < 5; i++) {
        std::cout << numbers[i] << std::endl;  // 输出每个元素
    }
    return 0;
}

三维数组

三维数组可以表示三维数据结构。例如，三维数组可以表示立方体或三维矩阵。

#include <iostream>

int main() {
    int array[2][2][2] = {0};  // 定义一个三维数组，2x2x2
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                array[i][j][k] = i * 4 + j * 2 + k;  // 赋值
            }
        }
    }
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                std::cout << array[i][j][k] << " ";  // 输出每个元素
            }
            std::cout << std::endl;
        }
    }
    return 0;
}

指针的概念与基本操作

指针是一个变量，它存储另一个变量的地址。使用指针可以更灵活地处理内存和数据。

定义指针

指针的定义包括指针类型和指针名称。使用*符号声明指针变量。

#include <iostream>

int main() {
    int a = 10;
    int *p;  // 定义一个整型指针
    p = &a;  // p指向变量a的地址
    std::cout << "Value: " << *p << std::endl;  // 输出a的值通过指针
    std::cout << "Address: " << p << std::endl;  // 输出a的地址
    return 0;
}

指针运算

指针可以进行加减运算，以获取数组或结构体中的下一个或上一个元素的地址。

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *p = arr;  // p指向数组的第一个元素
    for (int i = 0; i < 5; i++) {
        std::cout << *(p + i) << " ";  // 通过指针访问数组元素
    }
    p++;  // 指针向后移动一个元素
    std::cout << std::endl << *(p) << std::endl;  // 输出下一个元素
    return 0;
}

数组与指针的关系

数组和指针之间有密切的关系。数组的名称实际上是一个指向数组第一个元素的指针。

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *p = arr;  // p指向数组的第一个元素
    for (int i = 0; i < 5; i++) {
        std::cout << *(p + i) << " ";  // 通过指针访问数组元素
    }
    std::cout << std::endl;
    return 0;
}

通过上述示例代码，你可以更好地理解数组的定义与使用、指针的概念以及数组与指针之间的关系。

结构体与类的初步了解

结构体定义与使用

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

定义结构体

结构体定义包括结构体名称和成员变量。使用struct关键字来定义结构体。

#include <iostream>

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

int main() {
    Person person;
    person.name = "Alice";
    person.age = 30;
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

初始化结构体

结构体可以使用花括号初始化器进行初始化。

#include <iostream>

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

int main() {
    Person person = {"Bob", 25};
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

访问结构体成员

结构体成员可以通过.操作符访问。

#include <iostream>

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

int main() {
    Person person;
    person.name = "Charlie";
    person.age = 35;
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

类的基本概念

类是一种用户自定义的数据类型，用于封装数据和相关的操作。类的成员可以是数据成员（变量）和成员函数（方法）。

定义类

类定义包括类名称和成员。使用class关键字定义类。

#include <iostream>

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

int main() {
    Person person;
    person.name = "David";
    person.age = 40;
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

初始化类对象

类对象可以使用花括号初始化器进行初始化。

#include <iostream>

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

int main() {
    Person person = {"Eve", 45};
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

访问类成员

类成员可以通过.操作符访问。

#include <iostream>

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

int main() {
    Person person;
    person.name = "Frank";
    person.age = 50;
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    return 0;
}

类的成员函数与构造函数

类的成员函数定义类的行为，构造函数用于初始化对象。

定义成员函数

成员函数定义包括访问修饰符（如public、private）、返回类型、函数名和参数列表。

#include <iostream>

class Person {
public:
    std::string name;
    int age;
    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person person;
    person.name = "George";
    person.age = 55;
    person.printInfo();
    return 0;
}

构造函数

构造函数是特殊类型的成员函数，用于初始化对象。构造函数的名称与类名称相同，没有返回类型。

#include <iostream>

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

int main() {
    Person person("Harry", 60);
    person.printInfo();
    return 0;
}

默认构造函数

默认构造函数可以用于创建类的默认实例。

#include <iostream>

class Person {
public:
    std::string name;
    int age;
    Person() {
        name = "Default";
        age = 0;
    }
};

int main() {
    Person person;
    person.printInfo();
    return 0;
}

拷贝构造函数

拷贝构造函数用于复制类的实例。

#include <iostream>

class Person {
public:
    std::string name;
    int age;
    Person(const Person &other) {
        name = other.name;
        age = other.age;
    }
};

int main() {
    Person person1("Jane", 70);
    Person person2 = person1;  // 使用拷贝构造函数
    person2.printInfo();
    return 0;
}

通过上述示例代码，你可以更好地理解结构体的定义和使用以及类的基本概念和成员函数的定义。