C++ · 代码笔记1 · 从C到C++-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_49927539/article/details/136451479

前言
010命名空间
020bool值与使用
030C与CPP对const变量处理的方式不一致
040CPP中的const的作用域限定为当前文件的解决方法
050new关键字和delete关键字
060内联函数简单例子
070内联函数定义在头文件中
071CPP函数中的默认参数_常量指定
072CPP函数中的默认参数_表达式指定
080默认参数在作用域中仅能指定一次
090CPP的函数重载
101函数重载过程中的二义性和类型转换1
102函数重载过程中的二义性和类型转换2
110C与CPP混合开发时需要编写的保护宏

前言

1、编程环境

编码所用IDE：VScode 1.87.0
编译工具：gcc version 11.4.0（确实是使用了g++ -v来查看版本）

在这里插入图片描述

运行环境：
1、Windows Subsystem for Linux (WSL) 2
2、Ubuntu 22.04.4 LTS

在这里插入图片描述

2、编译命令

如无特别说明，通用编译命令为：

g++ -std=c++11 -Wall -o main filename.cpp

3、标题名前缀解释

XXX1或XXX2中，XXX代表一个主题，凡是具有相同的XXX，都是同一主题。

010命名空间

相关代码：

#include <stdio.h>

/**
 * @brief 命名空间NameSpace
 *
 * 包含学生类Student的定义。
 */
namespace NameSpace
{
    /**
     * @brief 学生类Student
     *
     * 用于表示一个学生的信息，包括姓名、年龄和分数。
     */
    class Student
    {
    public:
        char *name;  // 学生姓名
        int age;     // 学生年龄
        float score; // 学生分数

        /**
         * @brief 打印学生信息
         *
         * 输出学生的姓名、年龄和分数到标准输出。
         */
        void say(void)
        {
            printf("学生 %s 的年龄为 %d 岁， 总分为 %.2f 分\n", name, age, score);
        }
    };
}

int main(int argc, char const *argv[])
{
    NameSpace::Student stu; // 创建一个Student对象
    stu.name = "张三";      // 设置学生姓名
    stu.age = 18;           // 设置学生年龄
    stu.score = 90.99f;     // 设置学生分数

    stu.say(); // 调用say方法打印学生信息
    return 0;  // 程序正常退出
}

运行结果：

在这里插入图片描述

020bool值与使用

相关代码：

#include <iostream>

// 使用标准命名空间std，以便直接使用其中的对象和函数，例如cout和endl
using namespace std;

int main(int argc, char const *argv[])
{
    // 声明一个布尔类型的变量flag
    bool flag;

    // 判断10是否大于20，结果为假，将flag赋值为false
    flag = 10 > 20;
    // 输出flag的值
    std::cout << "flag = " << flag << std::endl;

    // 判断10是否小于等于20，结果为真，将flag赋值为true
    flag = 10 <= 20;
    // 输出flag的值
    std::cout << "flag = " << flag << std::endl;

    // 直接将flag赋值为true
    flag = true;
    // 输出flag的值
    std::cout << "flag = " << flag << std::endl;

    // 直接将flag赋值为false
    flag = false;
    // 输出flag的值
    std::cout << "flag = " << flag << std::endl;

    // 程序正常退出，返回0
    return 0;
}

运行结果：

在这里插入图片描述

030C与CPP对const变量处理的方式不一致

相关代码：

#include <iostream>

using namespace std;

int main(int argc, char const *argv[])
{
    // 在C++中，const 限定一个变量更像是 #define 命令，
    // 在编译阶段，所有包含 number 的地方都会直接被替换成 10
    const int number = 10;
    int *number_p = (int *)&number;

    // 虽然通过指针的方式对变量进行改变，但在编译阶段 number 已经被替换了
    // 所以以下输出语句还是会输出 10
    *number_p = 100;
    printf("number = %d\n", number);

    return 0;
}

运行结果：

在这里插入图片描述

040CPP中的const的作用域限定为当前文件的解决方法

相关代码：

// head.h

// 由于C++中 const 全局变量的可见范围仅限于当前文件，在其他文件中不可见
// 所以它可以定义在头文件中，多次引入后也不会出错。
const int number = 100;
void func(void);

// sub_file.cpp
#include <stdio.h>
#include "./head.h"

void func(void)
{
    printf("sub_file.h 文件读到number的数据为： %d\n", number);
}

// main.cpp
#include <stdio.h>
#include "./head.h"

// 需使用编译命令：
//  g++ -std=c++11 -Wall -o main sub_file.cpp main.cpp

int main(int argc, char const *argv[])
{
    func();
    printf("main.c 文件读取到的数据为：%d\n", number);
    return 0;
}

运行结果：

在这里插入图片描述

050new关键字和delete关键字

相关代码：

#include <iostream>

using namespace std;

// new 用来动态分配内存，delete 用来释放内存。
//  new 和 delete、new[] 和 delete[] 操作符应该成对出现，
// 并且不要和C语言中 malloc()、free() 一起混用。
int main(int argc, char const *argv[])
{
    int *int_p = new int;
    delete int_p;

    int *int_arr_p = new int[100];
    delete[] int_arr_p;

    return 0;
}

运行结果：

在这里插入图片描述

060内联函数简单例子

相关代码：

#include <iostream>

using namespace std;

/**
 * @brief 交换两个整数变量的值
 *
 * 该函数接收两个整数指针，通过指针交换这两个指针指向的整数值。
 *
 * @param num1 指向第一个整数的指针
 * @param num2 指向第二个整数的指针
 * @note  额外说明：内联函数可以定义在头文件中（不用加 static 关键字）
 *            并且头文件被多次#include后也不会引发重复定义错误。
 */
inline void swap_func(int *num1, int *num2)
{
    int temp = *num1; // 临时变量，用于存储num1的值
    *num1 = *num2;    // 将num1指向的值设置为num2指向的值
    *num2 = temp;     // 将num2指向的值设置为临时变量存储的原始num1的值
}


int main(int argc, char const *argv[])
{
    int number1, number2; // 声明两个整数变量
    cout << "请输入两个数：";
    cin >> number1 >> number2; // 从标准输入读取两个整数到number1和number2

    // 输出原始的两个数值
    cout << "number1 = " << number1 << "，number2 = " << number2 << endl;
    swap_func(&number1, &number2); // 调用swap_func函数交换两个变量的值
    // 输出交换后的两个数值
    cout << "number1 = " << number1 << "，number2 = " << number2 << endl;
    return 0; // 程序执行成功，返回0
}

运行结果：

在这里插入图片描述

070内联函数定义在头文件中

相关代码：

// head.h

#include <iostream>

inline void func(void)
{
    std::cout << "内联函数func()" << std::endl;
}

// main.cpp
#include <iostream>
#include "./head.h"

int main(int argc, char const *argv[])
{
    func();
    std::cout << "main()函数内部。" << std::endl;
    return 0;
}

运行结果：
在这里插入图片描述

071CPP函数中的默认参数_常量指定

相关代码：

#include <iostream> // 引入输入输出流库

// 定义一个函数func，接受一个整型参数int_number，一个双精度浮点型默认参数double_number和一个字符串默认参数str
// 注意！在给定的作用域中一个形参只能被赋予一次默认参数。
void func(int int_number, double double_number = 2.0, std::string str = "test.txt")
{
    // 输出传入的参数值
    std::cout << "int_number = " << int_number         // 输出整型参数
              << "，double_number = " << double_number // 输出双精度浮点型参数
              << "，str = " << str << std::endl;       // 输出字符串参数
}

// 程序的入口点
int main(int argc, char const *argv[])
{
    // 调用func函数，只传入整型参数，其他参数使用默认值
    func(123);
    // 程序正常退出
    return 0;
}

运行结果：

在这里插入图片描述

072CPP函数中的默认参数_表达式指定

相关代码：

#include <iostream>

// 全局整型变量，初始化为10
int int_var = 10;

/**
 * @brief func 函数输出三个参数的值。
 *
 * 该函数接受一个整型参数，一个双精度浮点型参数和一个字符串参数。
 * 双精度浮点型和字符串参数有默认值，分别由全局变量int_var计算得出和常量字符串"test.txt"。
 *
 * @param int_number 输入的整型参数。
 * @param double_number 输入的双精度浮点型参数，默认值为int_var+2.0。
 * @param str 输入的字符串参数，默认值为"test.txt"。
 * @note  注意！在给定的作用域中一个形参只能被赋予一次默认参数。
 */
void func(int int_number, double double_number = int_var + 2.0, std::string str = "test.txt")
{
    // 输出三个参数的值
    std::cout << "int_number = " << int_number
              << "，double_number = " << double_number
              << "，str = " << str << std::endl;
}

int main(int argc, char const *argv[])
{
    // 调用func函数，仅提供整型参数，其他参数使用默认值
    func(123);

    // 程序正常退出
    return 0;
}

运行结果：

在这里插入图片描述

080默认参数在作用域中仅能指定一次

相关代码：

#include <iostream>

// 事实上这样也合法
// 在本作用域中，一个形参仅被赋予一次默认参数
void func(int number1, int number2 = 20);
void func(int number1 = 10, int number2);


void func(int number1, int number2)
{
    std::cout << "number1 = " << number1 << "，number2 = " << number2 << std::endl;
}

int main(int argc, char const *argv[])
{
    func();
    return 0;
}

运行结果：

在这里插入图片描述

090CPP的函数重载

相关代码：

#include <iostream>

using namespace std;

// 参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。

/**
 * @brief Swap 交换两个整型指针指向的值。
 *
 * 该函数接受两个整型指针参数，并交换它们指向的值。
 *
 * @param a 第一个整型指针。
 * @param b 第二个整型指针。
 */
void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

/**
 * @brief Swap 交换两个浮点型指针指向的值。
 *
 * 该函数接受两个浮点型指针参数，并交换它们指向的值。
 *
 * @param a 第一个浮点型指针。
 * @param b 第二个浮点型指针。
 */
void Swap(float *a, float *b)
{
    float temp = *a;
    *a = *b;
    *b = temp;
}

/**
 * @brief Swap 交换两个字符型指针指向的值。
 *
 * 该函数接受两个字符型指针参数，并交换它们指向的值。
 *
 * @param a 第一个字符型指针。
 * @param b 第二个字符型指针。
 */
void Swap(char *a, char *b)
{
    char temp = *a;
    *a = *b;
    *b = temp;
}

/**
 * @brief Swap 交换两个布尔型指针指向的值。
 *
 * 该函数接受两个布尔型指针参数，并交换它们指向的值。
 * 注意：这里使用char类型的临时变量来交换bool值，因为bool在C++中通常被视为整数类型，
 *       且大小至少为一个字节，这样可以确保交换操作的准确性。
 *
 * @param a 第一个布尔型指针。
 * @param b 第二个布尔型指针。
 */
void Swap(bool *a, bool *b)
{
    char temp = *a;
    *a = *b;
    *b = temp;
}

int main()
{
    // 交换 int 变量的值
    int n1 = 100, n2 = 200;
    Swap(&n1, &n2);
    cout << n1 << ", " << n2 << endl;

    // 交换 float 变量的值
    float f1 = 12.5, f2 = 56.93;
    Swap(&f1, &f2);
    cout << f1 << ", " << f2 << endl;

    // 交换 char 变量的值
    char c1 = 'A', c2 = 'B';
    Swap(&c1, &c2);
    cout << c1 << ", " << c2 << endl;

    // 交换 bool 变量的值
    bool b1 = false, b2 = true;
    Swap(&b1, &b2);
    cout << b1 << ", " << b2 << endl;

    return 0;
}

运行结果：

在这里插入图片描述

101函数重载过程中的二义性和类型转换1

相关代码：

#include <iostream>
using namespace std;

void func(char ch)
{
    cout << "#1" << endl;
}

void func(int n)
{
    cout << "#2" << endl;
}

void func(long m)
{
    cout << "#3" << endl;
}

void func(double f)
{
    cout << "#4" << endl;
}

int main()
{
    short s = 99;
    float f = 84.6;

    func('a'); // 不需要类型转换，调用func(char)
    func(s);   // 将short转换成int，调用func(int)
    func(49);  // 不需要类型转换，调用func(int)
    func(f);   // 将float转换成double，调用func(double)
    return 0;
}

运行结果：

在这里插入图片描述

102函数重载过程中的二义性和类型转换2

注意！此程序编译会直接报错！这是因为编译器无法根据数据类型匹配到对应的函数，毕竟实参都满足所有函数的形参类型

相关代码：

#include <iostream>
using namespace std;

void func(char ch)
{
    cout << "#1" << endl;
}

void func(long m)
{
    cout << "#3" << endl;
}

void func(double f)
{
    cout << "#4" << endl;
}

int main()
{
    short s = 99;
    float f = 84.6;

    func('a');
    // 会报错，变量 s 和 49 都可以调用上面3个函数，不知道应该具体调用哪个
    func(s);
    func(49);
    
    func(f);
    return 0;
}

出现编译出错的结果：

在这里插入图片描述

110C与CPP混合开发时需要编写的保护宏

相关代码：

// head.h
/**
 * @brief   此头文件包含了C语言兼容的C++函数声明。
 * 这个头文件定义了一个可以在C++中调用的C语言函数。
 * 由于C和C++在函数声明和名称修饰(name mangling)方面存在差异，
 * 因此在C++中使用C库函数时，需要使用extern "C"声明来告诉编译器
 * 不对此函数进行C++的名称修饰。
 */

// 如果定义了__cplusplus宏，则说明当前环境是C++编译器
#ifdef __cplusplus
// 开始一个extern "C"块，告诉编译器下面的代码应该按照C语言的规则来编译
extern "C"
{
#endif

    // 函数声明：display
    // 无参数，无返回值
    void display(void);

// 如果定义了__cplusplus宏，结束extern "C"块
#ifdef __cplusplus
}
#endif

// sub_file.c
#include <stdio.h>
#include "./head.h"

void display(void)
{
    printf("sub_file.c 文件内函数。\n");
}

// main.cpp
#include <iostream>
#include "./head.h"

// 编译命令为：
//  g++ -std=c++11 -Wall -o main sub_file.c main.cpp

int main(int argc, char const *argv[])
{
    display();
    return 0;
}