当前位置：首页C++ > 正文

【家长收藏】少儿编程【信息学奥赛】之C++的基础知识归纳总结

作者：野牛程序员：2023-07-29 08:48:22C++阅读 3178

野牛程序员教少儿编程及信息学奥赛：电话|微信：15892516892

野牛程序员将逐一详细总结C++基础中的每个知识点，以便孩子们更好地理解和掌握。让我们开始吧！    

  1. 数据类型： 数据类型用于声明不同类型的变量，帮助计算机理解和处理数据。常见的数据类型有：

    • 整型：用于表示整数，如int、short、long等。

    • 浮点型：用于表示小数，如float和double。

    • 字符型：用于表示单个字符，如char。

    • 布尔型：用于表示真或假，只有两个值：true和false。

    • 声明和定义变量：在使用变量之前，需要声明它们的数据类型和名称。例如：int num; 这里声明了一个名为 num 的整型变量。

    • 定义常量：使用 const 关键字来定义常量，常量的值在程序运行时不能被修改。例如：const int MAX_SIZE = 100;

    • 要点：C++还支持自定义的数据类型（结构体和联合体）。

  2. 程序结构： C++程序的基本结构由头文件和主函数组成。

    • 头文件声明：头文件通常包含函数的声明，使用 #include 预处理指令将头文件包含到源文件中。例如：#include <iostream>

    • 主函数：是程序的入口，在其中编写主要的代码逻辑。

    int main(){ 
  /* code */ 
  return 0; 
} 
  
具体示例：  
#include <iostream>
using namespace std;
int main(){
  // 主函数代码
          
  cout << "Result: " << result << endl;
  return 0;
}

当复习C++的基础知识时，理解运算符的详细使用非常重要。让我们进一步详细地讲解每个运算符的用法和示例：

  1. 三目运算符： 三目运算符也称为条件运算符，它是一个有三个操作数的运算符。它的形式是condition ? expression1 : expression2，其中condition是一个表达式，如果它的值为真(true)，则返回expression1的值；否则返回expression2的值。

    int num = 5;
string result = (num > 0) ? "Positive" : "Non-positive";

  2. 算术运算符： 算术运算符用于进行基本的数学运算，包括加法、减法、乘法、除法和取余等。

  3. int a = 10, b = 3;
int sum = a + b;         // 加法，结果为13
int difference = a - b;  // 减法，结果为7
int product = a * b;     // 乘法，结果为30
int quotient = a / b;    // 除法，结果为3
int remainder = a % b;   // 取余，结果为1

  4. 关系运算符： 关系运算符用于比较两个值之间的关系，返回真(true)或假(false)的结果。

  5. int a = 5, b = 10;
bool isEqual = (a == b);          // 等于，结果为false
bool isNotEqual = (a != b);       // 不等于，结果为true
bool isGreater = (a > b);         // 大于，结果为false
bool isLess = (a < b);            // 小于，结果为true
bool isGreaterOrEqual = (a >= b); // 大于等于，结果为false
bool isLessOrEqual = (a <= b);    // 小于等于，结果为true

  6. 逻辑运算符： 逻辑运算符用于进行逻辑操作，对于布尔值进行运算，返回真(true)或假(false)的结果。

  7. bool p = true, q = false;
bool logicalAnd = p && q;   // 逻辑与，结果为false
bool logicalOr = p || q;    // 逻辑或，结果为true
bool logicalNotP = !p;      // 逻辑非，结果为false
bool logicalNotQ = !q;      // 逻辑非，结果为true

  8. 自增、自减运算符： 自增运算符（++）用于将变量的值增加1，自减运算符（--）用于将变量的值减少1。这两个运算符有前缀和后缀两种用法。

  9. int num = 5;
int prefixIncrement = ++num; // 前缀自增，num的值为6
int suffixDecrement = num--; // 后缀自减，suffixDecrement的值为6，num的值为5

当在C++中同时使用多个运算符时，它们的执行顺序由运算符的优先级决定。优先级高的运算符先执行，优先级相同的运算符按照从左到右的顺序执行。以下是常见运算符的优先级排列，从高到低：

  1. 高优先级运算符：

    1. 括号：() (圆括号内的表达式优先计算)

    2. 后缀运算符：++ (后缀自增)、-- (后缀自减)

  2. 中优先级运算符：

    1. 前缀运算符：++ (前缀自增)、-- (前缀自减)、+ (正号)、- (负号)、! (逻辑非)

  3. 乘法、除法和取余运算符：

    1. * (乘法)

    2. / (除法)

    3. % (取余)

  4. 加法和减法运算符：

    1. + (加法)

    2. - (减法)

  5. 关系运算符：

    1. > (大于)、< (小于)、>= (大于等于)、<= (小于等于)

  6. 相等性运算符：

    1. == (等于)、!= (不等于)

  7. 逻辑与运算符：

    1. && (逻辑与)

  8. 逻辑或运算符：

    1. || (逻辑或)

  9. 三目运算符：

    1. ? : (条件运算符)

  10. 低优先级运算符：

    1. 赋值运算符：=

    2. 复合赋值运算符：+=、-=、*=、/=、%= 等

注意：虽然上述是常见运算符的优先级排列，但为了代码的可读性和避免歧义，建议在表达式中使用括号来明确运算的顺序。例如，在复杂的表达式中使用括号来确保期望的运算顺序。这样可以避免因为优先级引起的错误。

在编写代码时，了解运算符的优先级非常重要，以确保表达式的计算顺序符合预期。同时，运算符的优先级还能帮助我们编写简洁而具有可读性的代码。

  1. 条件分支： 条件分支用于根据不同条件执行不同的代码块。

    • if语句：用于执行满足条件的代码块。

    • else if语句：用于在前一个条件不满足的情况下检查新的条件。

    • else语句：用于处理其他所有情况。

    • 要点：条件分支只会执行其中一个分支，需要注意条件之间的先后顺序。

    int num = 10;
if (num > 0) {
    cout << "Positive" << endl;
} else if (num < 0) {
    cout << "Negative" << endl;
} else {
    cout << "Zero" << endl;
}

  2. if嵌套语句：if语句的嵌套指的是在if或else if语句的代码块内部再嵌套使用另一个if或else if语句。这样可以构建更复杂的条件分支逻辑。

  3. if(条件1){
   if(条件2){
      做事情A
   }else{
      做事情B
   }
}else{
   if(条件3){
     做事情C
   }
   做事情D
}
或：
if (条件1) {
   做事情1        
} else if (条件2) {
   做事情2;        
} else if (条件3) {
   做事情3;        
} else if (条件4) {
   做事情4;
 } else {
    做其他;        
 }
假设我们要根据学生的成绩来判断他们的等级，成绩的分数范围为0到100。等级的划分如下：
90分以上为优秀
80分到89分为良好
70分到79分为中等
60分到69分为及格
60分以下为不及格

#include <iostream>
int main() {
    int score;
    std::cout << "请输入学生的成绩：";
    std::cin >> score;

    if (score >= 90) {
        cout << "优秀" << endl;
    } else if (score >= 80) {
        cout << "良好" << endl;
    } else if (score >= 70) {
        cout << "中等" << endl;
    } else if (score >= 60) {
        cout << "及格" << endl;
    } else {
        cout << "不及格" << endl;
    }

    return 0;
}

  4. Switch语句：switch语句根据表达式的值选择执行不同的分支。注意：在 case 内部需要使用 break 来结束该分支。

  • 要点：default标签是可选的，用于处理未匹配到任何case的情况。

    switch (expression) {
    case value1:
        // 代码块1
        break;
    case value2:
        // 代码块2
        break;
    // ...
    default:
        // 默认代码块
}

  1. 循环语句：

  • 重点：了解各种循环的应用场景。for循环用于已知次数的重复操作，while和do...while适用于未知次数的循环。

  • 要点：在使用循环时，注意循环条件和循环体内的操作，防止出现死循环。

  1. while循环：while循环在循环条件为真时重复执行代码块，直到条件为假。

    while (condition) {
    // 循环体
}
    
举例：
int i = 0;
while (i < 5) {
    cout << i << " ";
    i++;
}

  2. do...while循环：do...while循环首先执行一次代码块，然后在条件为真的情况下重复执行，直到条件为假。

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

举例：
int i = 0;
do {
   cout << i << " ";
   i++;
} while (i < 5);

  3. for循环：for循环在已知循环次数的情况下重复执行代码块。

  4. for (init; condition; increment) {
    // 循环体
}
举例：
for (int i = 0; i < 5; i++) {
    cout << i << " ";
}

  5. 循环嵌套： 循环嵌套是将一个或多个循环放在另一个循环的循环体内，用于处理复杂的重复操作。

  • 重点：理解嵌套循环的概念，可以在内层循环中使用外层循环控制变量。

  • 要点：嵌套循环的次数不宜过多，否则会增加代码的复杂性。

    for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        // 循环体
    }
}
举例：
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        cout << "(" << i << ", " << j << ") ";
    }
    cout << endl;
}

  1. 一维数组： 数组是一组相同数据类型的元素集合，用于存储多个相似的值。

  • 声明数组：int arr[5];，这里声明了一个包含5个整数元素的数组。

  • 数组初始化：int arr[5] = {1, 2, 3, 4, 5};

  • 访问数组元素：使用索引来访问数组元素，索引从0开始。

  • 要点：数组的索引从0开始，最大索引为数组长度减1，注意数组越界问题。

  1. int numbers[5]; // 声明一个包含5个整数元素的数组
int numbers[5] = {1, 2, 3, 4, 5}; // 声明并初始化数组
int value = numbers[2]; // 访问数组元素

  2. 二维数组： 二维数组是包含行和列的数组，可用于表示表格或矩阵。

  3. int matrix[3][3]; // 声明一个3x3的二维数组
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 声明并初始化二维数组
int value = matrix[1][2]; // 访问二维数组元素

  4. 字符数组作字符串： 字符数组可以用来存储和处理字符串，以空字符('\\0')结尾表示字符串的结束。

  • 要点：字符串的长度等于字符数组中字符的个数，不包括空字符。
  1. char str[6] = {'H', 'e', 'l', 'l', 'o', '\\0'}; // 字符数组作字符串
char str[] = "Hello"; // 简化写法

  • 常见的字符串函数的总结

  1. strlen：计算字符串的长度，不包括空字符('\\0')。

#include <cstring>
char str[] = "Hello";
int length = strlen(str); // 结果为5，不包括空字符

  1. strcpy：复制字符串到目标字符数组中。

#include <cstring>
char source[] = "Hello";
char destination[20];
strcpy(destination, source); // 复制source到destination

  1. strcat：连接两个字符串，将第二个字符串追加到第一个字符串的末尾。

#include <cstring>
char str1[] = "Hello";
char str2[] = " World";
strcat(str1, str2); // 连接结果为"Hello World"

  1. strcmp：比较两个字符串，根据字典顺序返回一个整数。

  • 返回值为0：表示两个字符串相等。

  • 返回值小于0：表示第一个字符串小于第二个字符串。

  • 返回值大于0：表示第一个字符串大于第二个字符串。

#include <cstring>
char str1[] = "apple";
char str2[] = "banana";
int result = strcmp(str1, str2); // 结果为负数，因为"apple"在字典顺序上比"banana"小

  1. strstr：在字符串中搜索子字符串，并返回子字符串第一次出现的位置。（没教）

#include <cstring>
char str[] = "Hello, World!";
char sub[] = "World";
char* position = strstr(str, sub); // 返回"World!"在str中的位置

  1. strchr：在字符串中搜索指定字符，并返回第一次出现的位置。（没教）

#include <cstring>
char str[] = "Hello, World!";
char ch = 'o';
char* position = strchr(str, ch); // 返回'o'在str中的位置

  1. strtok：将字符串分割成多个子字符串，使用指定的分隔符进行分割。（没教）

#include <cstring>
char str[] = "apple,banana,orange";
char delimiter[] = ",";
char* token = strtok(str, delimiter); // 返回"apple"，并在str中插入'\\0'作为结束符
while (token != nullptr) {
    // 继续获取下一个子字符串
    token = strtok(nullptr, delimiter);
}

  1. memset：将字符数组（字符串）中的每个字符都设置为指定的值。（没教）

#include <cstring>
char str[10];
memset(str, 'A', sizeof(str)); // 将str中的每个字符都设置为'A'

  1. memcpy：将源字符数组（字符串）中的内容复制到目标字符数组中。（没教）

#include <cstring>
char source[] = "Hello";
char destination[10];
memcpy(destination, source, sizeof(source)); // 将source复制到destination

  1. memcmp：比较两个字符数组（字符串）的前n个字符，根据字典顺序返回一个整数。（没教）

#include <cstring>
char str1[] = "apple";
char str2[] = "banana";
int n = 3;
int result = memcmp(str1, str2, n); // 比较前3个字符，结果为负数，因为"app"在字典顺序上比"ban"小

  1. strncpy：复制源字符数组（字符串）的前n个字符到目标字符数组中，如果不够n个字符则用空字符填充。

#include <cstring>
char source[] = "Hello";
char destination[10];
int n = 5;
strncpy(destination, source, n); // 复制前5个字符，目标数组中剩余位置用'\\0'填充

  1. strncat：连接两个字符串的前n个字符，将第二个字符串的前n个字符追加到第一个字符串的末尾。

#include <cstring>
char str1[] = "Hello";
char str2[] = " World";
int n = 5;
strncat(str1, str2, n); // 连接前5个字符，结果为"Hello World"

  1. sprintf：将格式化的数据写入字符串中，类似于printf，但输出到字符数组（字符串）（没教）。

#include <cstdio>
char str[20];
int num = 123;
sprintf(str, "Number: %d", num); // 将格式化数据写入str，结果为"Number: 123"


  1. 字符串类    ： C++提供了string类来处理字符串，不需要手动处理空字符。

  • 要点：使用string类可以更方便地处理字符串，不需要手动处理空字符。

  1. #include <string>
string str = "Hello"; // 使用string类处理字符串

  2. 函数： 函数是一段完成特定任务的代码块，可重复调用，可以接收参数和返回值。

  • 函数的声明：在使用函数之前，需要先声明函数的原型。

  • 函数的定义：函数的实际代码实现。

  • 重点：了解函数的声明和定义的区别，了解函数参数的传递方式。

  • 要点：函数可以有返回值，也可以没有返回值(void)，需要注意返回值的类型和返回值的用途。

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

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

  2. 结构体： 结构体是一种用户自定义的数据类型，可包含不同类型的数据成员。

  • 结构体声明：

  1. struct MyStruct {

 /* 成员 */ 
 
};

  • 结构体变量定义：MyStruct myVar;

  • 重点：结构体是一种自定义的数据类型，可以包含多个不同类型的数据成员。

  • 要点：结构体的变量可以通过.来访问成员。

  1. // 结构体声明
struct Person {
    std::string name;
    int age;
};

// 结构体变量定义
Person person1;
person1.name = "Alice";
person1.age = 30;

  2. 联合体： 联合体是一种特殊的数据类型，可以在同一块内存空间存储不同的数据类型。

  • 联合体声明：

  1. union MyUnion { 

/* 成员*/ 

};

  • 联合体变量定义：union MyUnion myVar;

  • 重点：联合体是一种特殊的数据类型，多个成员共用同一块内存空间。

  • 要点：在使用联合体时，只能同时使用其中一个成员。

  1. // 联合体声明
union Data {
    int num;
    float fnum;
};

// 联合体变量定义
Data data;
data.num = 10;

  2. 指针： 指针是用来存储变量地址的变量，通过指针间接访问和修改变量的值。

  • 指针的声明：int *ptr;，这里声明了一个指向整型变量的指针。

  • 指针的定义：int num = 5; int *ptr = &num;，这里定义了指针 ptr 并使其指向变量 num。

  • 重点：指针是用来存储变量地址的变量，了解指针的定义和初始化。

  • 要点：指针的解引用操作（*ptr）可以访问指针指向的变量。

  1. int num = 5;
int *ptr = &num; // 定义指针并使其指向变量num
cout << *ptr << endl; // 通过指针访问变量的值

  2. 结构体指针： 结构体指针可以用来指向结构体对象，并通过指针访问结构体成员。

  • 结构体指针的声明和定义：struct MyStruct *ptr;

  • 重点：结构体指针用于指向结构体变量，通过指针可以访问结构体成员。

  • 要点：使用结构体指针时，需要确保指针指向的结构体变量是有效的。

    struct Person {
    string name;
    int age;
};

Person person1;
Person *ptr = &person1; // 定义结构体指针并使其指向结构体变量
cout << ptr->name << endl; // 通过指针访问结构体成员

  1. 链表： 链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针，可以动态地进行节点的插入和删除。

  • 链表节点定义：

  1. struct Node { 

   /* data */ 
   Node* next; 
};

  • 链表的操作：添加节点、删除节点、遍历链表等。

  • 重点：了解链表的概念和节点的结构，掌握链表的插入和删除操作。

  • 要点：遍历链表时要注意空指针（nullptr）的判断，以免访问非法内存。

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

Node* head = nullptr; // 链表头节点

// 链表节点插入示例
Node* newNode = new Node;
newNode->data = 10;
newNode->next = nullptr;
if (head == nullptr) {
    head = newNode; // 空链表，将头节点指向新节点
} else {
    newNode->next = head; // 将新节点插入头部
    head = newNode; // 更新头节点
}


野牛程序员教少儿编程与信息学奥赛-微信|电话：15892516892
野牛程序员教少儿编程与信息学竞赛-微信|电话：15892516892
相关推荐

最新推荐

热门点击