5 C++ 基本语法规则
发表更新编程 / C++小白5 分钟读完 (大约809个字)

5 C++ 基本语法规则

C++ 是一种通用编程语言，具有丰富的语法和功能。以下是 C++ 的基本语法规则，适合小白学习。

1. 程序结构

C++ 程序通常由以下几个部分组成：

1
2
3
4
5
6
#include <iostream> // 头文件引用

int main() { // 主函数
    std::cout << "Hello, World!" << std::endl; // 输出语句
    return 0; // 返回值
}
  • #include <iostream> 用于包含输入输出库。
  • int main() 是程序的入口。
  • std::cout 用于输出到控制台。

2. 注释

C++ 支持两种注释形式：

  • 单行注释：// 这是一个单行注释
  • 多行注释：/* 这是一个多行注释 */

例子：

1
2
3
4
5
// 这是一个单行注释
/*
这是一个多行注释
可以写多行内容
*/

3. 数据类型

C++ 支持多种数据类型，主要分为基本数据类型和用户定义数据类型。

3.1 基本数据类型

  • int：整数类型
  • float：单精度浮点数
  • double：双精度浮点数
  • char：字符类型
  • bool：布尔类型（真或假）

示例：

1
2
3
4
5
int a = 10;      // 整数
float b = 5.5;  // 单精度浮点数
double c = 3.14; // 双精度浮点数
char d = 'A';    // 字符
bool e = true;   // 布尔值

3.2 用户定义数据类型

  • struct：结构体
  • class：类

示例：

1
2
3
4
5
6
7
8
9
10
11
struct Person {
    std::string name;
    int age;
};

class Animal {
public:
    void speak() {
        std::cout << "Animal speaks!" << std::endl;
    }
};

4. 变量与常量

4.1 变量

变量是用来存储数据的命名内存地址。C++ 中，变量需要先声明后使用。

1
2
int x;        // 声明变量 x
x = 5;       // 赋值

4.2 常量

常量是不可改变的变量，通常使用 const 关键字声明。

1
const int MAX = 100; // 常量 MAX

5. 控制结构

控制结构用于控制程序的执行流程，常见的控制结构有条件语句和循环语句。

5.1 条件语句

C++ 使用 if、else if 和 else 来处理条件。

1
2
3
4
5
6
7
8
int num = 10;
if (num > 0) {
    std::cout << "正数" << std::endl;
} else if (num < 0) {
    std::cout << "负数" << std::endl;
} else {
    std::cout << "零" << std::endl;
}

5.2 循环语句

常用的循环语句有 for、while 和 do while。

5.2.1 for 循环

1
2
3
for (int i = 0; i < 5; i++) {
    std::cout << "计数：" << i << std::endl;
}

5.2.2 while 循环

1
2
3
4
5
int j = 0;
while (j < 5) {
    std::cout << "计数：" << j << std::endl;
    j++;
}

5.2.3 do while 循环

1
2
3
4
5
int k = 0;
do {
    std::cout << "计数：" << k << std::endl;
    k++;
} while (k < 5);

6. 函数

函数是 C++ 的基本构建块之一，用于封装特定的功能。

6.1 函数声明

函数在使用前需要声明。

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

6.2 函数定义

定义函数的具体实现。

1
2
3
int add(int a, int b) {
    return a + b; // 返回值
}

6.3 函数调用

调用之前定义好的函数。

1
2
3
4
5
int main() {
    int result = add(5, 3); // 调用函数
    std::cout << "结果是：" << result << std::endl;
    return 0;
}

7. 数组

数组是存储相同类型数据的集合。

1
int arr[5] = {1, 2, 3, 4, 5}; // 整数数组

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

1
std::cout << arr[0]; // 输出第一个元素

8. 字符串

C++ 提供了 std::string 类型来处理字符串。

1
2
3
4
#include <string>

std::string message = "Hello, C++!";
std::cout << message << std::endl;

总结

以上是 C++ 的基本语法规则，学习者可以通过理解和实践这些语法规则，逐步掌握 C++ 编程的基础知识。

6 自定义异常类的设计
发表更新编程 / C++进阶5 分钟读完 (大约788个字)

6 自定义异常类的设计

在C++中，异常处理是保证程序稳定性的重要机制。标准库提供了一些内置异常类，但在实际开发中，我们常常需要定义自己的异常类以适应特定的应用场景。下面将详细介绍如何设计自定义异常类。

1. 什么是自定义异常类

自定义异常类是用户自定义的类，继承自标准异常类（如 std::exception），用于表示特定的错误信息。自定义异常类可以携带额外的信息，有助于错误的诊断与处理。

2. 自定义异常类的基本设计

在 C++ 中，设计自定义异常类一般需要遵循以下步骤：

  1. **继承自 std::exception**：为了与标准异常处理机制兼容，自定义异常类需要继承自 std::exception。

  2. 定义构造函数：通过构造函数传递错误信息，用于初始化异常对象。

  3. 重写 what() 方法：该方法用于返回异常信息的字符串，通常会返回传递给构造函数的错误消息。

示例代码

下面是一个简单的自定义异常类的实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <exception>
#include <string>

// 自定义异常类
class MyException : public std::exception {
private:
    std::string message; // 存储异常信息

public:
    // 构造函数
    MyException(const std::string& msg) : message(msg) {}

    // 重写 what() 方法
    virtual const char* what() const noexcept override {
        return message.c_str(); // 返回异常信息
    }
};

// 一个可能抛出异常的函数
void mightGoWrong() {
    throw MyException("Something went wrong in mightGoWrong!");
}

int main() {
    try {
        mightGoWrong(); // 调用可能抛出异常的函数
    } catch (const MyException& e) {
        std::cerr << "Caught MyException: " << e.what() << std::endl; // 捕获并处理异常
    }
    return 0;
}

输出结果

1
Caught MyException: Something went wrong in mightGoWrong!

3. 拓展自定义异常类

可以根据需要扩展自定义异常类，添加更多的信息。例如，您可以添加一个错误代码属性，或者使用不同的构造函数来传递更多信息。

修改后的示例代码

以下是扩展自定义异常类以包含错误代码的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <exception>
#include <string>

// 自定义异常类
class MyException : public std::exception {
private:
    std::string message;
    int errorCode;

public:
    // 构造函数
    MyException(const std::string& msg, int code) : message(msg), errorCode(code) {}

    // 重写 what() 方法
    virtual const char* what() const noexcept override {
        return message.c_str();
    }

    // 获取错误代码的方法
    int getErrorCode() const noexcept {
        return errorCode;
    }
};

// 一个可能抛出异常的函数
void mightGoWrong() {
    throw MyException("Something went wrong in mightGoWrong!", 404);
}

int main() {
    try {
        mightGoWrong();
    } catch (const MyException& e) {
        std::cerr << "Caught MyException: " << e.what() 
                  << " with error code: " << e.getErrorCode() << std::endl;
    }
    return 0;
}

输出结果

1
Caught MyException: Something went wrong in mightGoWrong! with error code: 404

4. 总结

自定义异常类提供了灵活的异常处理机制，允许开发者创建符合特定需求的异常类型。通过继承 std::exception 并重写 what() 方法，我们可以详细描述错误信息，帮助应用程序进行有效的错误管理。在实际开发中，合理使用自定义异常类可以提高程序的稳定性和可维护性。

6 C++中的注释与代码格式
发表更新编程 / C++小白6 分钟读完 (大约918个字)

6 C++中的注释与代码格式

在C++编程中，注释和代码格式是非常重要的，良好的注释和格式可以提升代码的可读性与可维护性。本节将详细介绍C++中的注释方式及基本的代码格式规范。

一、注释

在C++中，注释是用来解释代码的，帮助阅读者理解代码的用途和逻辑。注释不会被编译器执行，是程序中用来说明代码的一部分。

1. 单行注释

单行注释使用 // 来标识。// 之后的内容都是注释，直到该行结束。例如：

1
2
// 这是一个单行注释
int a = 5; // 这也是一个单行注释

2. 多行注释

多行注释使用 /* 开始，以 */ 结束。多行注释可以跨越多行，适合较长的解释。例如：

1
2
3
4
5
/*
这是一个多行注释。
可以用于解释较长的逻辑或代码段。
*/
int b = 10;

3. 注意事项

  • 尽量避免使用多行注释嵌套，因为这在C++中是不被允许的，会导致编译错误。
  • 注释应该简洁明了，避免冗长，使其易于理解。

二、代码格式

良好的代码格式有助于提高代码的可读性和可维护性。以下是一些基本的代码格式规范。

1. 缩进

使用一致的缩进风格，建议使用四个空格（或一个制表符），且不要混合使用。缩进用于表示代码块的层次关系。例如：

1
2
3
4
5
6
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl; // 输出消息
    return 0;  // 返回0表示程序正常结束
}

2. 空行

使用空行来分隔逻辑上相关的代码块，使代码更易读。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

int main() {
    // 初始化变量
    int a = 5;
    int b = 10;

    // 计算和
    int sum = a + b;

    std::cout << "Sum: " << sum << std::endl;
    
    return 0;
}

3. 代码行长度

尽量保持每行代码的长度不超过80到120个字符，以便于阅读。长行可以考虑拆分。例如：

1
2
std::cout << "这是一个非常长的输出信息，"
             "它需要在下一行继续。" << std::endl;

4. 花括号的风格

花括号 {} 的使用要整齐，可以选择在同一行或者新开一行开始。常见风格有：

  • K&R风格（花括号在同一行）：
1
2
3
if (a > b) {
    std::cout << "a is greater" << std::endl;
}
  • Allman风格（花括号新开一行）：
1
2
3
4
if (a > b)
{
    std::cout << "a is greater" << std::endl;
}

5. 变量和函数命名

  • 使用有意义的名称，能反映变量或函数的用途。
  • 变量名一般采用小写字母，单词之间用下划线分隔，例如 my_variable。
  • 函数名一般采用小写字母，单词之间用下划线分隔，例如 my_function()。
1
2
3
int calculate_sum(int x, int y) {
    return x + y;
}

三、示例代码

结合上述注释与代码格式规范，下面是一个完整的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>

// 计算两个整数的和
int calculate_sum(int x, int y) {
    return x + y; // 返回和
}

int main() {
    int a = 5;   // 第一个整数
    int b = 10;  // 第二个整数

    // 计算和
    int result = calculate_sum(a, b);

    // 输出结果
    std::cout << "Sum: " << result << std::endl;

    return 0; // 程序正常结束
}

总结

良好的注释和规范的代码格式是编写高质量C++程序的重要组成部分。通过合理使用 // 和 /* */ 注释，结合良好的缩进、空行、命名习惯，可以有效提升代码的可读性和可维护性。

链接

分类

最新文章

标签

AI必备微积分24
AI概率论25
AI线性代数28
Apache2网站部署24
C++77
CDN加速18
CSS31
C语言92
Django开发35
Flask开发30
GAN29
GenerativeAI33
HTML25
Hexo网站开发30
Java76
Javascript30
LangChain28
Markdown30
Matplotlib18
Node.js30
NumPy22
Pandas21
PyQt533
PyTorch31
Python78
React40
TensorFlow30
Vue39
数据分析18
数据挖掘20
机器学习24
深度学习24
神经网络后门攻击26
统计学24
计算机网络24
计算机视觉32
×