【C++】知识点汇总(上)

C++知识点复习上

  • 一、C++ 概述
    • 1. 基本数据类型
    • 2. 变量定义和访问
    • 3. 常量与约束访问
  • 二、程序控制结构详解与示例
    • 1. 表达式
    • 2. 选择控制
      • 2.1 if 语句
      • 2.2 switch 语句
    • 3. 循环控制
      • 3.1 for 循环
      • 3.2 while 循环
      • 3.3 do-while 循环
    • 4. goto 语句
    • 5. 控制语句的嵌套
  • 三、函数
    • 1. 函数的定义和调用
    • 2. 函数参数传递
    • 3. 调用机制
    • 4. 函数地址和指针
    • 5. 内联与重载
    • 6. 多文件程序和命名空间
  • 四、数组和动态存储
    • 1. 一维数组
    • 2. 二维数组
    • 3. 指针数组
    • 4. 动态存储
    • 5. Vector类
    • 6. String类
    • 7.比较
  • 五、集合与结构
    • 1. 位运算
      • 1.1 与运算(AND)
      • 1.2 或运算(OR)
      • 1.3 异或运算(XOR)
    • 2. 集合基本运算
      • 2.1 并集
      • 2.2 交集
      • 2.3 差集
    • 3. 结构的定义与访问
    • 4. 结构数组和链表
      • 4.1 结构数组
      • 4.2 链表

一、C++ 概述

C++ 是一种强大且广泛使用的编程语言,它结合了 C 语言的高效性和面向对象编程的特性。本文将介绍 C++ 的一些基本概念,包括基本数据类型、变量定义和访问,以及常量与约束访问。通过实际例子和表格,将了解这些重要的概念。

1. 基本数据类型

在 C++ 中,基本数据类型是构建其他数据类型的基石。以下是一些常见的基本数据类型:

类型 描述 大小
int 整数类型 4 字节
float 单精度浮点数 4 字节
double 双精度浮点数 8 字节
char 字符类型 1 字节
bool 布尔类型 1 字节

2. 变量定义和访问

在 C++ 中,变量是用于存储数据值的标识符。以下是变量的定义和访问的示例:

// 变量定义
int age;
float height;

// 变量赋值
age = 25;
height = 1.75;

// 变量访问
cout << "年龄:" << age << " 岁" << endl;
cout << "身高:" << height << " 米" << endl;

3. 常量与约束访问

常量是在程序执行期间不能被修改的值,而约束访问则是通过修饰符确保函数中的某些行为。以下是常量和约束访问的例子:

// 常量定义
const float PI = 3.14159;
const int MAX_AGE = 100;

// 约束访问
void printMessage(const string& message) {
    cout << message << endl;
}

int main() {
    printMessage("Hello, C++!");
    return 0;
}

在上述示例中,PIMAX_AGE 是常量,它们的值在程序运行期间不会改变。而 printMessage 函数中的 const string& message 表示 message 参数是一个常量引用,禁止在函数中修改传递的字符串。

二、程序控制结构详解与示例

程序控制结构是编程中至关重要的一部分,它决定了程序执行的流程和逻辑。接下来浅示七种表达式、两种选择控制、三种循环控制、goto 语句以及控制语句的嵌套。通过详细的例子和表格,将更好地理解这些控制结构的使用。

1. 表达式

表达式是编程语言中的基本构建块,它们用于执行特定的计算。以下是七种常见的表达式:

  1. 算术表达式: 执行基本的算术运算。

    int result = 5 + 3 * 2;
    
  2. 关系表达式: 比较两个值之间的关系。

    bool isEqual = (x == y);
    
  3. 逻辑表达式: 使用逻辑运算符组合多个条件。

    boolean isTrue = (a && b) || (c || d);
    
  4. 赋值表达式: 将一个值赋给一个变量。

    int a = 10;
    
  5. 条件表达式(三元运算符): 根据条件选择不同的值。

    var result = (x > 0) ? "Positive" : "Negative";
    
  6. 位运算表达式: 对二进制位进行操作。

    int result = a & b;
    
  7. sizeof 表达式: 返回数据类型的大小。

    size_t size = sizeof(int);
    

2. 选择控制

选择控制结构用于根据条件执行不同的代码块。

2.1 if 语句

if condition:
    # 如果条件成立执行此处代码
else:
    # 否则执行此处代码

示例:

int num = 5;
if (num % 2 == 0) {
    System.out.println("偶数");
} else {
    System.out.println("奇数");
}

2.2 switch 语句

switch (expression) {
    case value1:
        // 如果 expression 等于 value1 执行此处代码
        break;
    case value2:
        // 如果 expression 等于 value2 执行此处代码
        break;
    default:
        // 如果 expression 不等于任何一个 value 执行此处代码
}

示例:

char grade = 'B';
switch (grade) {
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好");
        break;
    default:
        System.out.println("其他");
}

3. 循环控制

循环控制结构允许我们多次执行相同的代码块。

3.1 for 循环

for (initialization; condition; update) {
    // 循环体
}

示例:

for (int i = 1; i <= 5; i++) {
    Console.WriteLine(i);
}

3.2 while 循环

while (condition) {
    // 循环体
}

示例:

int count = 0;
while (count < 5) {
    print(count)
    count += 1
}

3.3 do-while 循环

do {
    // 循环体
} while (condition);

示例:

int i = 0;
do {
    console.log(i);
    i++;
} while (i < 5);

4. goto 语句

goto 语句允许直接跳转到程序中的标记位置。

if (condition) {
    goto label;
}

// 其他代码

label:
// 标记位置的代码

示例:

x = 0

if x == 0:
    goto exit

# 其他代码

exit:
# 退出标记

5. 控制语句的嵌套

控制语句可以嵌套,形成复杂的逻辑结构。

示例:

for (int i = 0; i < 3; i++) {
    if (i == 0) {
        System.out.println("i 是 0");
    } else {
        System.out.println("i 不是 0");
    }
}

三、函数

当谈论C++编程时,函数是一个非常重要的概念。函数允许我们将代码组织成可重用的模块,提高代码的可读性和维护性。包括函数的定义和调用、函数参数传递、调用机制、函数地址和指针、内联与重载、以及多文件程序和命名空间。

1. 函数的定义和调用

在C++中,函数的定义包括函数名、返回类型、参数列表和函数体。下面是一个简单的例子:

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

int main() {
    // 函数的调用
    int result = add(3, 5);
    return 0;
}

2. 函数参数传递

C++支持多种函数参数传递方式,包括值传递、引用传递和指针传递。看下面的例子:

// 值传递
void incrementByValue(int x) {
    x++;
}

// 引用传递
void incrementByReference(int &x) {
    x++;
}

// 指针传递
void incrementByPointer(int *x) {
    (*x)++;
}

int main() {
    int num = 10;

    incrementByValue(num);
    // num的值不变

    incrementByReference(num);
    // num的值加1

    incrementByPointer(&num);
    // num的值再次加1

    return 0;
}

3. 调用机制

C++函数调用机制涉及栈和堆的管理,以及函数的入栈和出栈过程。这是一个复杂的话题,我们将简要介绍。函数的调用涉及以下步骤:

  • 将参数推送到栈上
  • 跳转到函数的地址
  • 执行函数体
  • 将结果返回给调用者

4. 函数地址和指针

在C++中,函数也有地址,可以通过函数指针来调用函数。下面是一个示例:

// 函数指针的声明
int (*addPointer)(int, int);

// 函数指针的赋值
addPointer = &add;

// 使用函数指针调用函数
int result = addPointer(3, 5);

5. 内联与重载

内联函数可以提高函数调用的效率,而函数重载允许我们定义多个同名函数,根据参数的类型和数量进行区分。看下面的例子:

// 内联函数
inline int multiply(int a, int b) {
    return a * b;
}

// 函数重载
int add(int a, int b) {
    return a + b;
}

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

6. 多文件程序和命名空间

在大型项目中,将代码分为多个文件是一种良好的实践。同时,命名空间可以避免命名冲突。示例如下:

文件1: math_functions.h

namespace Math {
    int add(int a, int b);
    double multiply(double a, double b);
}

文件2: math_functions.cpp

#include "math_functions.h"

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

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

文件3: main.cpp

#include "math_functions.h"

int main() {
    int result = Math::add(3, 5);
    double product = Math::multiply(2.5, 4.0);
    return 0;
}

四、数组和动态存储

在编程中,数组是一种基本的数据结构,用于存储相同类型的元素。对于一维数组、二维数组、指针数组、动态存储以及C++中的vector和string类。将通过例子和表格演示它们的用法和区别。

1. 一维数组

一维数组是具有相同数据类型的元素的有序集合。声明和初始化一个一维整数数组的示例:

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

2. 二维数组

二维数组是包含行和列的数组。下面是一个2x3的整数二维数组的声明和初始化:

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

3. 指针数组

指针数组是一个数组,其中的元素是指针。以下是一个包含指向整数的指针的数组的示例:

int a = 5, b = 10, c = 15;
int* ptrArr[3] = {&a, &b, &c};

4. 动态存储

动态存储允许在运行时分配内存。使用new关键字在堆上动态分配内存:

int* dynamicArr = new int[5];
dynamicArr[0] = 10;
dynamicArr[1] = 20;
// ... 使用动态数组
delete[] dynamicArr; // 释放内存

5. Vector类

C++中的std::vector是一个动态数组,可以自动调整大小。以下是一个使用vector的示例:

#include 
std::vector<int> vec = {1, 2, 3, 4, 5};
vec.push_back(6); // 添加元素

6. String类

C++中的std::string是处理字符串的类。以下是一个使用string的示例:

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

7.比较

在下表中,对这些数组和动态存储的不同方面进行了比较:

特性 一维数组 二维数组 指针数组 动态存储 Vector类 String类
声明与初始化 int arr[5]; int matrix[2][3]; int* ptrArr[3]; int* dynamicArr = new int[5]; std::vector vec; std::string str;
内存管理 动态增长
大小可变性 静态 静态 静态 动态 动态 动态

五、集合与结构

集合与结构是两个基本而重要的概念。包括位运算、集合基本运算、结构的定义与访问,以及结构数组和链表的应用。通过例子和表格,将介绍这些概念。

1. 位运算

位运算是在二进制位上执行操作的一种技术。以下是一些常见的位运算操作:

1.1 与运算(AND)

int result = a & b; // 将a和b的每个对应位进行与运算

1.2 或运算(OR)

int result = a | b; // 将a和b的每个对应位进行或运算

1.3 异或运算(XOR)

int result = a ^ b; // 将a和b的每个对应位进行异或运算

2. 集合基本运算

集合是一个独特的数据结构,常用于存储不重复的元素。以下是一些集合的基本运算:

2.1 并集

set<int> unionSet = setA;
unionSet.insert(setB.begin(), setB.end());

2.2 交集

set<int> intersectionSet;
set_intersection(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(intersectionSet, intersectionSet.begin()));

2.3 差集

set<int> differenceSet;
set_difference(setA.begin(), setA.end(), setB.begin(), setB.end(), inserter(differenceSet, differenceSet.begin()));

3. 结构的定义与访问

结构是一种用户自定义的数据类型,可以包含不同类型的数据。以下是结构的定义和访问:

struct Point {
    int x;
    int y;
};

Point p1;
p1.x = 10;
p1.y = 20;

4. 结构数组和链表

4.1 结构数组

结构数组是一组相同类型的结构的集合。以下是一个点的结构数组的例子:

Point pointsArray[5];
pointsArray[0].x = 1;
pointsArray[0].y = 2;
// 其他元素的赋值类似

4.2 链表

链表是一种动态数据结构,它可以动态增长和缩小。以下是一个简单链表的例子:

struct Node {
    int data;
    Node* next;
};

Node* head = new Node();
head->data = 1;
head->next = new Node();
head->next->data = 2;
head->next->next = nullptr;

你可能感兴趣的:(c++,开发语言,c语言,经验分享,笔记)