【C++】【期末考】【基本概念和语法】概括总结——期末速成

小李很执着

发布于 2024-06-17 07:59:32

730

发布于 2024-06-17 07:59:32

文章被收录于专栏：学习笔记学习笔记

1. C++简介

C++的历史与发展

C++是一种面向对象的编程语言，由Bjarne Stroustrup在20世纪80年代初开发。它是在C语言的基础上增加了面向对象的特性，从而既具有C语言的高效性，又提供了高级的编程抽象。C++已经成为许多系统级软件、游戏、嵌入式系统以及高性能计算应用程序的主要编程语言。

C++的特点与优势

面向对象编程：支持类和对象、继承、多态和封装。
高效性：C++编译后的程序运行速度很快，接近于C语言。
灵活性：支持多范式编程，包括面向对象、泛型编程和过程式编程。
丰富的库：拥有丰富的标准库（STL），提供了大量的容器和算法。

2. 基本语法

注释

C++支持单行注释和多行注释。

// 这是单行注释
/*
这是
多行
注释
*/

数据类型与变量

C++支持多种基本数据类型，包括整型（int）、字符型（char）、浮点型（float, double）等。

int a = 10;
char b = 'A';
float c = 3.14;

C++还支持布尔型（bool），用于表示真（true）或假（false）。

bool isTrue = true;

常量

常量可以使用const关键字定义，一旦定义不能改变。

const int MAX = 100;

在C++11及之后的版本中，可以使用constexpr关键字定义常量表达式。

constexpr int MIN = 1; // 常量表达式

运算符

C++提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符等。

int a = 5 + 3; // 加法
bool b = (a > 3) && (a < 10); // 逻辑与

C++还支持位运算符，用于按位操作。

int x = 5; // 0101
int y = 3; // 0011
int z = x & y; // 0001，按位与运算

输入与输出

使用cin进行输入，使用cout进行输出。

int num;
std::cin >> num;
std::cout << "Number is " << num << std::endl;

还可以使用getline函数读取一整行输入。

std::string line;
std::getline(std::cin, line); // 读取一整行输入
std::cout << "Line is: " << line << std::endl;

3. 控制结构

条件语句

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

if (condition) {
    // statements
} else if (another_condition) {
    // statements
} else {
    // statements
}

switch (variable) {
    case value1:
        // statements
        break;
    case value2:
        // statements
        break;
    default:
        // statements
}

示例：根据用户输入的年龄判断是否成年。

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

循环语句

循环语句用于重复执行代码块。

for (int i = 0; i < 10; ++i) {
    // statements
}

while (condition) {
    // statements
}

do {
    // statements
} while (condition);

示例：打印从1到10的数字。

for (int i = 1; i <= 10; ++i) {
    std::cout << i << std::endl;
}

4. 函数

函数定义与声明

函数是执行特定任务的代码块。

// 函数声明
int add(int a, int b);

// 函数定义
int add(int a, int b) {
    return a + b;
}

示例：定义一个函数计算两个数的乘积。

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

参数传递

参数传递可以通过值传递和引用传递。

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

示例：通过引用传递数组元素。

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

返回值

函数可以返回一个值，也可以返回多个值（通过指针或引用）。

int max(int a, int b) {
    return (a > b) ? a : b;
}

示例：返回两个数的较大值。

int getMax(int a, int b) {
    return (a > b) ? a : b;
}

函数重载

C++支持函数重载，即允许多个同名函数根据参数类型或数量的不同而存在。

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

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

示例：定义一个函数用于打印整数和一个用于打印浮点数。

void print(int num) {
    std::cout << "Integer: " << num << std::endl;
}

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

5. 数组与字符串

一维数组

一维数组用于存储相同类型的多个元素。

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

示例：遍历数组并打印元素。

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

字符串处理

C++标准库提供了string类用于字符串处理。

#include <string>
std::string str = "Hello, World!";

示例：拼接两个字符串。

std::string str1 = "Hello";
std::string str2 = "World";
std::string result = str1 + ", " + str2 + "!";
std::cout << result << std::endl;

6. 指针

指针的定义与使用

指针用于存储变量的内存地址。

int a = 10;
int *p = &a;

示例：通过指针修改变量的值。

*p = 20;
std::cout << "a = " << a << std::endl; // 输出20

指针运算

指针可以进行算术运算。

p++; // 移动到下一个内存位置

示例：遍历数组的指针。

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

指针与数组

指针可以用于遍历数组。

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

示例：数组名实际上是指向第一个元素的指针。

int *p = arr; // 数组名arr是一个指针，指向第一个元素

函数指针

函数指针用于指向函数。

void print(int a) {
    std::cout << a << std::endl;
}

void (*funcPtr)(int) = print;
funcPtr(10);

示例：使用函数指针数组调用不同的函数。

void func1(int a) { std::cout << "Function 1: " << a << std::endl; }
void func2(int a) { std::cout << "Function 2: " << a << std::endl; }

void (*funcArray[2])(int) = {func1, func2};
funcArray ;
funcArray ;

7. 引用

引用的定义与用法

引用是变量的别名。

int a = 10;
int &ref = a;

示例：通过引用修改变量的值。

ref = 20;
std::cout << "a = " << a << std::endl; // 输出20

引用与指针的区别

引用必须在定义时初始化且不能更改引用对象，而指针可以改变指向。

int a = 10;
int b = 20;
int *p = &a;
p = &b; // 允许
int &ref = a;
// ref = b; // 错误

示例：使用引用作为函数参数。

void increment(int &num) {
    num++;
}
int value = 5;
increment(value);
std::cout << "value = " << value << std::endl; // 输出6

8. 结构体与联合体

结构体定义与使用

结构体用于定义新的数据类型，包含多个成员变量。

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

Person person = {"John", 30};

示例：访问结构体成员。

std::cout << "Name: " << person.name << std::endl;
std::cout << "Age: " << person.age << std::endl;

联合体定义与使用

联合体用于在相同的内存位置存储不同类型的数据。

union Data {
    int i;
    float f;
    char c;
};

Data data;
data.i = 10;

示例：访问联合体成员。

data.f = 3.14;
std::cout << "Float: " << data.f << std::endl;

枚举类型

枚举类型用于定义一组命名常量。

enum Color { RED, GREEN, BLUE };
Color color = RED;

示例：使用枚举类型。

if (color == RED) {
    std::cout << "The color is red." << std::endl;
}

9. 类与对象

类的定义与成员

类是面向对象编程的基本单元，包含成员变量和成员函数。

class Box {
public:
    int length;
    int width;
    int height;
};

示例：定义类的成员函数。

class Box {
public:
    int length;
    int width;
    int height;
    
    int volume() {
        return length * width * height;
    }
};

对象的创建与使用

对象是类的实例，通过对象可以访问类的成员。

Box box;
box.length = 10;

示例：通过对象调用成员函数。

Box box;
box.length = 10;
box.width = 5;
box.height = 2;
std::cout << "Volume: " << box.volume() << std::endl;

构造函数与析构函数

构造函数用于初始化对象，析构函数用于清理资源。

class Box {
public:
    Box(int l, int w, int h) : length(l), width(w), height(h) {}
    ~Box() {}
private:
    int length;
    int width;
    int height;
};

示例：定义和使用构造函数和析构函数。

Box box(10, 5, 2);
std::cout << "Volume: " << box.volume() << std::endl;

类的继承

继承用于创建新的类，该类从现有类继承属性和行为。

class Rectangle : public Box {
public:
    Rectangle(int l, int w) : Box(l, w, 0) {}
};

示例：定义和使用派生类。

Rectangle rect(10, 5);
std::cout << "Area: " << rect.length * rect.width << std::endl;

多态与虚函数

多态允许通过基类指针或引用调用派生类的函数。

class Base {
public:
    virtual void show() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class" << std::endl;
    }
};

示例：使用多态调用虚函数。

Base *b;
Derived d;
b = &d;
b->show(); // 输出"Derived class"

运算符重载

运算符重载允许自定义运算符的行为。

class Complex {
public:
    int real, imag;
    Complex operator + (const Complex &obj) {
        Complex res;
        res.real = real + obj.real;
        res.imag = imag + obj.imag;
        return res;
    }
};

示例：重载加法运算符。

Complex c1{1, 2}, c2{3, 4};
Complex c3 = c1 + c2;
std::cout << "Sum: " << c3.real << " + " << c3.imag << "i" << std::endl;

10. 模板

函数模板

函数模板用于定义泛型函数。

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

示例：使用函数模板

std::cout << "Int sum: " << add(1, 2) << std::endl;
std::cout << "Double sum: " << add(1.1, 2.2) << std::endl;

类模板

类模板用于定义泛型类。

template <typename T>
class Box {
    T data;
public:
    Box(T val) : data(val) {}
    T getData() { return data; }
};

示例：使用类模板。

Box<int> intBox(10);
Box<double> doubleBox(3.14);
std::cout << "Int data: " << intBox.getData() << std::endl;
std::cout << "Double data: " << doubleBox.getData() << std::endl;

11. STL（标准模板库）

容器

STL容器用于存储和管理数据。

#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};

示例：使用vector容器。

vec.push_back(6);
for (int val : vec) {
    std::cout << val << " ";
}
std::cout << std::endl;

算法

STL算法用于操作容器数据。

#include <algorithm>
std::sort(vec.begin(), vec.end());

示例：使用sort算法对vector排序。

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

迭代器

迭代器用于遍历容器。

std::vector<int>::iterator it;
for (it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl;
}

示例：使用反向迭代器遍历容器。

for (std::vector<int>::reverse_iterator rit = vec.rbegin(); rit != vec.rend(); ++rit) {
    std::cout << *rit << " ";
}
std::cout << std::endl;

12. 文件操作

文件读写

C++提供了fstream库用于文件读写操作。

#include <fstream>
std::ofstream outFile("example.txt");
outFile << "Hello, World!" << std::endl;
outFile.close();

std::ifstream inFile("example.txt");
std::string line;
std::getline(inFile, line);
std::cout << line << std::endl;
inFile.close();

示例：写入和读取多个数据。

std::ofstream outFile("data.txt");
outFile << 1 << " " << 2 << " " << 3 << std::endl;
outFile.close();

std::ifstream inFile("data.txt");
int a, b, c;
inFile >> a >> b >> c;
std::cout << a << " " << b << " " << c << std::endl;
inFile.close();

文件流

文件流用于处理文件输入输出。

std::fstream file("example.txt", std::ios::in | std::ios::out);

示例：使用文件流进行读写操作。

std::fstream file("example.txt", std::ios::out | std::ios::in);
file << "New content" << std::endl;
file.seekg(0); // 移动到文件开头
std::string content;
std::getline(file, content);
std::cout << "Read from file: " << content << std::endl;
file.close();

13. 异常处理

异常处理用于处理程序中的错误情况。

try {
    // 可能抛出异常的代码
} catch (const std::exception &e) {
    std::cerr << "Exception: " << e.what() << std::endl;
} catch (...) {
    std::cerr << "Unknown exception" << std::endl;
}

示例：自定义异常类并抛出异常。

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "My custom exception";
    }
};

void functionThatThrows() {
    throw MyException();
}

int main() {
    try {
        functionThatThrows();
    } catch (const MyException &e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-06-16，如有侵权请联系 cloudcommunity@tencent.com 删除

c++

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度