C/C++ - Linux迷

Linux 内核中使用或依赖的 GCC 扩展代码示例

linuxmi — Sat, 18 Nov 2023 00:44:12 +0000

Linux内核因其高效性和灵活性而受到广泛赞誉，而在其基础中广泛利用了GNU编译器集合（GCC）的许多扩展功能。这些扩展在优化内核性能和确保在不同平台上的兼容性方面发挥着重要作用。在这里，我们将介绍一些主要的GCC扩展，附带代码示例，并解释它们的使用方法和优势。

GNU Compiler Collection（GCC）是由GNU项目开发的一套程序语言编译器集合。GCC由自由软件基金（FSF）发布，并在GNU通用公共许可证（GPL）下提供。

最初是为了C语言而启动的编译器，但目前支持多种编程语言，包括C++、Objective-C、Fortran、Ada、Go、D等。GCC提供了先进的优化功能，可在多个平台上提供可移植性，并使终端用户能够在许多平台上编译代码。

GCC具有以下特点：

可移植性: GCC可以在各种类型的处理器和操作系统上运行，使开发人员能够在不同的架构上使用相同的代码基础。
优化: GCC提供广泛的优化选项，可用于最大化性能。
语言支持: 除了C/C++之外，由于支持许多其他语言，因此可以满足各种项目的需求。
调试和错误报告: GCC通过错误消息和警告指出代码问题，使调试变得容易。
可扩展性: GCC支持语言和体系结构特定的扩展，可以访问非标准化语言功能和体系结构特定的指令。
自由软件: 由于在GPL下发布，可以自由使用、修改和重新分发。

GCC作为一个标准的编译器被广泛应用于许多开源项目，包括编译Linux内核，其稳健性和可靠性使其成为行业标准。

属性（Attributes）

示例：打包的结构体

struct __attribute__((packed)) tcp_header {
    uint16_t source_port;
    uint16_t dest_port;
    uint32_t sequence;
    uint32_t ack_sequence;
    uint16_t flags;
    uint16_t window_size;
    uint16_t checksum;
    uint16_t urgent_pointer;
};

解释：

在这里，我们对表示TCP头的结构体应用了__attribute__((packed))属性。该属性防止编译器在结构体成员之间插入填充，从而可以精确地控制内存上的布局，以适应网络通信的需要。

其他属性：

__attribute__((packed)): 在结构体成员之间紧密地打包，避免插入填充。
__attribute__((aligned(x))): 将变量或结构体对齐到指定的边界。
__attribute__((noreturn)): 通知编译器函数不会返回。
__attribute__((section("..."))): 将变量或函数放置在特定的节(section)中。

内建函数（Built-in Functions）：

例如：计算最高位。

unsigned int value = 0xFF00;
int msb = 32 - __builtin_clz(value);

解释：

__builtin_clz函数用于计算从值的开头开始的连续零的数量。在这个例子中，它被用于找到变量value的最高位（即最左侧的非零位），常用于位字段操作、资源分配等许多低级操作。它还可用于在位图中搜索空闲槽等场景。

例子：使用GCC内建函数进行内存操作

void *my_memcpy(void *dest, const void *src, size_t n) {
    return __builtin_memcpy(dest, src, n);
}

解释：

GCC内建函数__builtin_memcpy可能比标准的memcpy函数更高效，并且在特定的优化情况下可能进行了特殊处理。在内核中，使用这样的内建函数可以加速内存复制操作。

其他内建函数：

__builtin_popcount: 计算整数中1的位数。
__builtin_clz: 计算整数中开头的0的位数（Count Leading Zeros）。
__builtin_expect: 为了优化分支预测，向编译器提示某个条件最有可能是真的。

编译时断言

例子：编译时断言。

BUILD_BUG_ON(sizeof(mystruct) != expected_size);

解释：

BUILD_BUG_ON 是一个宏，在特定条件为真的情况下生成编译错误，这是在编译时进行的。借助于GCC的功能，内核开发者使用这个宏来确保数据结构具有期望的大小。

`typeof` 操作符

例子：变量类型的自动推断

#define min(x, y) ({             \
    typeof(x) _min1 = (x);       \
    typeof(y) _min2 = (y);       \
    (void) (&_min1 == &_min2);   \
    _min1 < _min2 ? _min1 : _min2; \
})

解释：

typeof 是一种由GCC引入的自动获取变量类型的扩展。在上述的 min 宏中，使用 typeof 推断了参数 x 和 y 的类型，然后基于这些类型进行了比较。这种技巧允许在保持类型安全性的同时进行通用操作。

寄存器变量

例子：将变量分配到特定寄存器

register unsigned long sp asm ("sp");

解释：

使用这个语法，内核开发人员可以直接将变量分配到特定的CPU寄存器。这在提高关键函数性能时可能会被使用，但需要非常谨慎。

用于多线程的扩展

例子：使用线程本地存储

__thread int my_thread_variable;

解释：

__thread 存储类说明符表示变量位于线程本地存储（TLS）中。这确保每个线程都有其自己的变量实例，对于需要每个内核线程都有其独特上下文的情况非常有用。

语句表达式（Statement Expressions）

例子：在宏内进行复杂计算

#define MAX(a, b) ({ \
    typeof(a) _a = (a); \
    typeof(b) _b = (b); \
    _a > _b ? _a : _b; \
})

解释：

通过使用这个语句表达式，可以在 MAX 宏内评估 a 和 b 的最大值，并返回结果。这种技巧在需要在宏内执行多个步骤并返回一个值的情况下非常有用。

更详细的解释：

如果不使用语句表达式，宏可能在某些情况下无法按预期工作。在不使用语句表达式的传统宏的情况下，如果参数包含具有副作用的表达式或者被多次评估，可能会导致问题。

例如，考虑以下简单的 MAX 宏：

#define MAX(a, b) ((a) > (b) ? (a) : (b))

这个宏在通常情况下可以正常工作，但如果包含有副作用的表达式，可能会导致意外的行为，例如，如果 a 或 b 中包含增量运算符（++）。

int x = 5;
int y = 10;
int z = MAX(x++, y++);

在上述代码中，由于 MAX 宏两次评估 x 和 y，可能导致与期望的结果不同的行为，即 x 和 y 的值以意外的方式更改。

相比之下，使用语句表达式的 MAX 宏如下：

#define MAX(a, b) ({ \
    typeof(a) _a = (a); \
    typeof(b) _b = (b); \
    _a > _b ? _a : _b; \
})

在这里，a 和 b 仅被评估一次，其结果分别存储在 _a 和 _b 中。这样，即使参数包含带有副作用的表达式，也只会评估一次，从而避免了意外的副作用问题。

例如，考虑以下的宏：

#define MAX(a, b) ((a) > (b) ? (a) : (b))

这个宏如果传递包含 ++ 的表达式，例如 MAX(x++, y++)，则可能被预处理器展开为以下形式：

((x++) > (y++) ? (x++) : (y++))

在展开的结果中，x 和 y 在宏内部被多次引用。在评估条件表达式 (x++) > (y++) 时，x 和 y 各自增加一次。然后，根据条件表达式的结果，x 或 y 将再次增加一次。因此，x 或 y 中的一个可能会意外地增加两次。

这种多次评估的问题，特别是涉及到具有副作用的操作（例如增量或减量）时，容易导致错误。因此，在将带有副作用的表达式作为宏的参数使用时，需要格外小心。通过使用语句表达式，每个参数只被评估一次并存储在临时变量中，可以防止这类问题的发生。

内联汇编语法（Inline Assembly）

例子：使用特定的汇编指令

void disable_interrupts() {
    __asm__ __volatile__("cli": : :"memory");
}

解释：

这个内联汇编命令 cli 会禁用 CPU 的中断。内核使用这样的低级别指令直接控制硬件，确保在关键操作期间不会发生中断。

指定初始化（Designated Initializers）

例子：结构体的初始化

struct point {
    int x;
    int y;
};

struct point p = {
    .x = 10,
    .y = 20
};

解释：

指定初始化器允许直接为结构体的特定成员分配值，使初始化更具可读性且减少错误。这种方法在只想初始化结构体的部分成员或者需要明确初始化顺序的情况下特别有用。

GCC 的扩展广泛用于 Linux 内核代码库的各个部分，通过有效地利用这些扩展，Linux 在各种硬件上展现出卓越性能。通过使用这些扩展，开发者能够更细粒度地控制内核的行为，实现高效的系统调用、硬件操作和数据处理。

为了实现 Linux 内核的高级功能和性能，它充分利用了 GCC（GNU Compiler Collection）的多样化扩展。这些扩展对于提升内核的性能、稳定性以及在不同平台上的兼容性至关重要。

相关：

Linux 下进行 C 或 C++ 编程时重要的 GCC 标志 https://www.linuxmi.com/gcc-flags.html
如何在 Ubuntu 20.04/22.04 上安装 GCC 编译器 https://www.linuxmi.com/ubuntu-20-04-22-04-gcc.html

The post Linux 内核中使用或依赖的 GCC 扩展代码示例 first appeared on Linux迷.

C 编程中指针的基本指南

linuxmi — Tue, 03 Oct 2023 00:51:28 +0000

指针对许多 C 编程至关重要，但它们可能很难理解。本文通过实际示例来复习它们的语法以及它们的工作原理。

指针是 C 编程中不可或缺的一部分，您需要深入理解它们才能有效使用这种编程语言。它们有助于高效的内存管理、通过引用传递数据、处理数组和字符串等等。然而，为了避免错误，需要谨慎使用它们。

探讨C指针的详细内容，从理解内存和地址到精通指针算术。

内存和地址

内存——通常用作RAM（随机访问存储器）的缩写——是计算机中用于存储程序运行所需数据和指令的空间。它充当程序的工作区。内存的最小单位通常是一个字节，相当于八位。

每个内存位置都有唯一的地址，并且可以根据计算机的不同存储不同数量的数据。当您在C中声明一个变量时，实际上是在为其分配一个内存位置来存储其数据。可以将其视为一栋房子，每栋房子都有一个唯一的地址，您可以使用该地址来找到它。

想象一下您计算机内存是一系列存储单元，每个存储单元包含一个字节的数据。假设在C程序中有两个变量x和y：

int x = 5;
int y = 10;

在内存中，它可能看起来像这样：

Address	Data
1000	5
1004	10

在这里，单独的内存位置存储了这些变量。变量x表示的数据位于内存地址1000，而y的数据占据了内存地址1004。

当您使用指针时，了解内存和地址是至关重要的，因为它们是存储内存地址的变量。它们允许您访问和操作存储在特定内存位置的数据。

在C中声明和初始化指针

在C中使用指针修改数据之前，您需要声明和初始化它。

声明

要声明一个指针，您需要指定它指向的数据类型，然后是一个星号(*)，然后是指针的名称。例如：

int *ptr;

在这里，int *ptr 声明了一个名为ptr的指针，它可以存储整数的内存地址。

初始化

声明后，您应该用它将要指向的内存地址进行初始化。可以像这样进行初始化：

int x = 5;
int *ptr = &x;

在这个声明中，& 运算符获取了x变量的地址。这段代码实际上表示”ptr是一个变量，它存储整数值的内存位置，而该位置就是x当前引用的位置”。

现在，ptr保存了整数变量x的地址。例如：

Variable	Address	Value
x	1000	5
ptr	—-	1000

解引用指针

在C中，解引用指针意味着访问由指针指向的内存地址中存储的值。

假设您有一个指针 int *ptr，它指向一个整数变量，并且该变量的值为10。要通过指针访问该值，您可以使用星号(*)运算符：

int x = 10;

int *ptr = &x; // ptr指向x的地址

int value = *ptr; // 解引用ptr以获取值

这个例子使用了ptr变量来检索它指向的内存地址中的值。因此，value现在保存了值10，这是x的内容。

指针算术

指针算术是C中的一个强大特性，特别适用于处理数组和字符串（它们是字符数组）等工作。它允许您对指针执行算术操作，以在内存中移动。

下面是一个示例，展示了如何使用它。

首先声明一个整数数组：

int numbers[] = {10, 20, 30};

声明一个指向整数的指针，并将numbers数组的内存位置分配给它：

int *ptr = numbers;

在这里，您不需要使用“&”运算符，因为numbers已经是一个隐式的指针类型。

现在，ptr变量指向数组的第一个元素：

printf("%d\n", *ptr); // 10

您可以通过将其增加2来将指针移到数组的第三个元素：

ptr += 2;
printf("%d\n", *ptr); // 30

您可以通过减去它来将指针向后移动：

ptr--;
printf("%d\n", *ptr); ;// 20

指针算术在导航数组和处理动态内存分配时特别有用。

C中的指针和函数

如果您了解C编程中函数的工作原理，那么您就可以很好地使用函数指针。以下是您可以使用它们的一些方法。

函数指针

您可以声明和使用函数指针来动态使用函数，就像使用任何其他值一样。这对于回调和动态函数执行特别有用。

int (*operation)(int, int); // 声明一个函数指针
operation = add; // 指向add函数的指针
int result = operation(5, 3); // 通过指针调用函数

这段代码声明了一个名为operation的函数指针，它可以指向一个接受两个整数并返回一个整数的函数。它将add函数（的指针）分配给了operation。然后，它使用operation变量间接调用add(5, 3)。

通过引用传递

指针允许您通过引用将参数传递给函数，使您能够在函数内修改原始数据。这对于需要更改变量值的函数而言非常重要，因为它们需要在其范围之外更改变量的值。

void modifyValue(int *x) {
*x = 42; // 修改调用代码中x的值
}

modifyValue函数改变了调用代码提供给它的任何参数的值，将其设置为42。

动态内存分配

函数可以返回指向动态分配内存的指针。当您需要创建和返回无界数据结构（如数组或链表）时，这是常见的情况。您需要对栈内存和堆内存有很好的了解才能使用它。

int *createArray(int size) {
int *arr = (int *)malloc(size * sizeof(int));
return arr;
}

这段代码定义了一个名为createArray的函数，该函数以一个整数size作为输入。在函数内部，它使用malloc动态分配了指定大小的整数数组的内存。在初始化数组后，它返回对这个新创建的数组的指针。

常见用途

指针在C中是非常重要的，它们是区分C和其他编程语言（如Python）的要素。以下是一些常见用途：

动态内存分配
数组操作
通过引用传递
数据结构
资源管理

了解指针的这些常见用途可以增强您的C编程技能。练习其中一些可以提高您对指针的理解。

在C编程中练习使用指针

掌握C编程中的指针是一项有价值的技能，它使您能够高效地管理内存、操作数据并执行高级操作。练习和熟练使用指针将极大地提高您创建强大且资源高效的C程序的能力。

The post C 编程中指针的基本指南 first appeared on Linux迷.

C 和 C++ 之间的 10 个主要区别

linuxmi — Sun, 03 Sep 2023 11:38:02 +0000

C 和 C++ 是两种因其低级别强大而广泛认可的编程语言。尽管这两种语言听起来很相似，在后者上只多了一个 “++”，但它们的特点和用法却有很大的不同。

C 是一种过程式编程语言，具有静态系统，而 C++ 是 C 的扩展版本，支持面向对象编程。因此，学习C是相关的，并有助于改善 C++ 编程。在热门编程语言中，C 和 C++ 是学习和技能发展的两种最受欢迎的语言之一。

相关：在Ubuntu 20.04/22.04 中安装配置 IDE 集成开发环境 Code::Blocks 20.03 https://www.linuxmi.com/ubuntu-codeblocks-20-03.html

C 编程语言：

C 是一种重要的通用计算机编程语言，支持结构化编程、典型的机器指令、递归和静态系统下的变量。C 编程语言提供低级别访问，可以处理地址、位和字节，并能对开发过程进行迅速控制。

Dennis M. Ritchie于1972年开发了C编程语言，用于UNIX操作系统。最初，程序员们使用C语言设计系统，主要关注操作系统。渐渐地，他们开始将其应用于开发编译器、汇编器、文本编辑器、数据库等。

在学习C编程之前，你应该了解相关的术语，如参数、函数、变量、类、内置类型、循环、数组等。这有助于进行一些代码练习。程序员们将C代码写在扩展名为”.c”或”.h”的文本文件中。

C++编程语言：

C++是C语言的增强版本，由Bjarne Stroustrup于1986年开发。它包含了C的所有部分，并添加了面向对象编程等功能。游戏开发人员经常使用C++，但它在软件基础设施和桌面应用程序中也有广泛的用途。

C++可以处理硬件任务，并在几乎任何环境中运行代码。因此，C++是创建动态和灵活的软件的首选之一，可以管理系统资源和关键任务。

与其他编程语言一样，C++支持类、方法、对象、多态、继承等特性。它通常使用文件扩展名”.cpp”和”.cxx”，你还可能看到像”.c++”、”.h”、”.hpp”、”.hxx”、”.h++”等扩展名用于头文件。

C++的最新版本是C++23，于2021年6月18日发布。

相关：

为什么要学 C++？ https://www.linuxmi.com/c-plus-plus-learn.html
认识 4 个用 C++ 制作的终端游戏和动画 https://www.linuxmi.com/c-terminal-games.html

C 与 C++：10个核心区别

C 和 C++ 都是通用的过程式语言。然而，它们之间的核心区别在于 C 编程语言不支持类和对象，而 C++ 体现了面向对象的编程范式。让我们找出 C 和 C++ 之间的核心区别。

过程

C 编程语言不支持面向对象编程。因此，它不允许多态性、继承等。作为一种面向对象的语言，C++ 支持多态性和继承。

安全性

由于 C 语言不允许封装，数据变得可访问，其他实体可以破坏它。然而，C++ 支持封装，可以保护数据结构并根据需要使用它。

方法

C 编程语言鼓励自顶向下的方法，首先定义一个通用问题，然后将其分解为较小的任务。另一方面，C++ 鼓励自底向上的方法。这涉及首先识别和定义类，然后使用它们执行最初的任务。

输入/输出函数

在 C 中，I/O 操作主要通过 C 标准库的标准 I/O 函数进行处理，如 printf() 和 scanf()。这些函数提供基本的格式化和读取功能，但缺少 C++ 中的一些高级功能。

另一方面，C++ 通过使用 iostream 库中的对象扩展了 I/O 功能，这些对象称为标准 I/O 流。cout 流允许进行简单而灵活的输出操作，而 cin 流提供了增强的输入功能。C++ 流支持运算符重载，可方便地输出复杂数据类型并启用自定义格式选项。

重载和覆盖

方法覆盖允许子类重新定义从其祖先继承的函数。重载允许同一个函数有多个版本，每个版本具有唯一的参数。C 不支持这两者，但 C++ 支持。

内存分配

C编程依赖于两个关键函数——calloc()和malloc()——用于内存分配。相应的free()函数用于内存释放。C++使用new运算符进行动态内存分配，使用delete运算符进行释放。

编译

C和C++的软件开发始于编写源代码。C文件的源代码具有.c扩展名，而C++使用扩展名如.cpp或.cxx。这些源代码文件包含程序的指令和逻辑。

下一步是预处理，预处理器处理#include指令并执行宏处理。此步骤确保源代码经过解析依赖关系和宏处理准备好进行编译。预处理阶段对C和C++都是相同的。

在编译阶段，源代码被传递给相应的编译器，例如C使用gcc，C++使用g++。编译器检查语法和语义，并报告错误。这一步对C和C++都适用。

主要区别在于C++中的额外功能，尤其是面向对象编程（OOP）概念。C++编译器处理所有类似C的语法，还包括封装、继承和多态性等OOP特性。

连接，在编译之后，通过组合对象文件、库文件和依赖项来创建可执行文件。它解决了外部引用，确保独立执行。连接对C和C++都是相同的。

平台

C和C++都有广泛的平台支持，可以在Windows、macOS、Linux以及不同的UNIX衍生系统等各种操作系统上运行。这种平台多样性允许开发人员在多个平台上无缝编译和运行C和C++代码。

许多集成开发环境（IDE）都支持C和C++。你可以使用一些流行的IDE，如Visual Studio、Code::Blocks、Dev-C++、Eclipse、Xcode和Qt Creator。这些IDE简化了代码编写、调试、编译和其他开发过程，提供了便捷高效的软件开发环境。

总之，C和C++具有广泛的平台支持，提供了多种IDE选择。这两种语言在不同平台和IDE上运行的能力帮助你轻松构建多功能应用程序。

变量

通常，C编程语言使用两种类型的值：字面值和变量。C使用四种基本的变量类型：int、float、char和double。C++的主要变量类型包括bool、void和wchar_t。

特点

C编程语言是一种过程式、快速和高效的语言，具有模块化和丰富的内置运算符。与C不同，C++是一种过程式语言，具有OOP。此外，它是机器无关的、简单的和区分大小写的。

C编程语言是一种中级语言，而C++是一种高级语言。

C语言	C++ 编程语言
无法运行 C++ 代码。	可以运行几乎所有的C代码。
不支持引用变量。	支持引用变量。
该语言有 32 个关键字。	95个关键词。他们中的一些人可能会被分到几个小组中。
通过头文件输入和输出。	使用头文件。
不允许在结构中使用函数。	允许结构中的函数。
分为程序和模块。	分为类和函数。

C编程语言示例

这个 C 程序使用了标准输入输出库 stdio.h。这个库提供了 printf 函数，程序使用它来输出消息 “Hello, Linux迷 www.linuxmi.com”，后面跟着一个换行字符 \n。

#include 
// Linux迷 www.linuxmi.com

int main () {
  printf("Hello, Linux迷 www.linuxmi.com\n");
  return 0;
}

C++ 编程语言示例

这个 C++ 程序使用了输入输出流库iostream。这个库允许程序使用流运算符，如 std::cout << 对象代表标准输出，通常情况下将是控制台。

包含 std::endl 会导致消息后面添加一个换行字符。这比C 的 “\n” 字符是一个更高级的抽象，因此这个程序将在使用不同字符表示换行的系统上运行。

#include 
// Linux迷 www.linuxmi.com

int main () {
  std::cout << "Hello, Linux迷 www.linuxmi.com" << std::endl;
  return 0;
}

C 和 C++ 在可预见的未来仍然具有潜力

许多程序员和技术爱好者曾预期 C 和 C++ 将失去重要性。然而，由于它们的开发特性和广泛的应用领域，C 和 C++ 仍然是令人兴奋的职业道路。

其他编程语言不断涌现，但通常满足特定需求，如 Web 开发或游戏编程。C 和 C++ 是更通用的语言，学习它们将对你的职业非常有价值，即使只是作为学习其他语言的基础。

The post C 和 C++ 之间的 10 个主要区别 first appeared on Linux迷.

在 C++ 中比较数字时要小心

linuxmi — Sun, 23 Apr 2023 06:04:36 +0000

C++ 是一种广泛使用的编程语言，但也是编程错误最常见的语言之一。其中许多错误是由于逻辑错误造成的。特别是，比较操作中的错误可能会影响代码的准确性和可靠性。

C++ 语言中有一种特定的比较错误，许多新开发人员会忽略这种错误。这种错误是由于对操作符在执行多个比较时的工作原理的错误理解而导致的。了解如何避免这个常见错误以及为什么会发生这个错误。

C++ 中的比较

C++编程语言提供了许多不同的功能和工具，包括基本的操作，如比较运算符。比较运算符是编程语言中的特殊操作，您可以使用它们将数据与彼此进行比较。开发人员经常使用这些运算符，特别是在创建算法时。

在日常生活中，您可以在许多不同的例子中看到比较运算符。例如，当您在杂货店购物时，您会心里比较价格。如果一种产品的价格比另一种低，您会选择那种产品。

在 if-else 语句中经常会看到比较运算符。比较运算符是检查一个值是否大于、小于或等于另一个值的地方。有一个非常小但重要的细节不应该忽视，即比较表达式的结果返回true或false，这是布尔值。这些值是编程中控制结构的基本组成部分之一。

例如，在C++编程语言中，“==”运算符检查两个值是否相等。如果这两个值相等，结果返回 true，否则结果将是 false。

if (a == b)
{
    return true;
} 
else
{
    return false;
}

比较问题的示例

C++ 初学者常犯的一个错误是使用比较运算符。这些运算符允许程序员比较两个值，并根据比较结果执行不同的操作。然而，如果使用这些运算符不正确，可能会导致意想不到的错误。

例如，尽管表达式 3 < 15 < 10 在数学上是不正确的，但是 C++ 将其结果视为 true。您可以通过编写以下简单的测试程序来证明这一点。

首先，创建一个名为 linuxmi.cpp 的文件。使用您喜欢的代码编辑器打开此文件，并添加以下代码：

#include 
int a = 15;

int main()
{
    if (3 < a < 10)
    {
        std::cout << "foo" << std::endl;
    }
    else
    {
        std::cout << "boo" << std::endl;
    }

    return 0;
}

您可以使用此命令来编译和运行代码：

linuxmi@linuxmi:~/www.linuxmi.com$ g++ linuxmi.cpp -o linuxmi

现在你有一个名为 linuxmi 的程序。运行程序并检查其输出。

C++ 认为 3 < 15 < 10 是正确的，即使它在数学上是不正确的。那么造成这种结果的原因是什么？

C++中的比较问题原因

和大多数编程语言一样，C++ 从左到右读取代码。每个比较运算符都会产生一个布尔值。布尔值不仅代表 true 和 false，还有一个数学等价物。

计算机的工作原理依赖于 0 和 1。对于计算机来说，某件事情的结果只能是 true 或 false。计算机程序通常将数字 1 视为 true，数字 0 视为 false。

再次仔细查看比较问题，并从左到右阅读该语句，你会发现有两个不同的比较。第一个比较是在数字 3 和 15 之间。这是一个 true 值，因为 3 小于 15。

第二个比较是针对该结果和数字 10 之间的比较。由于需要进行数字比较，C++ 会将布尔值 true 静默转换为 1。1 小于 10，因此总的结果是 true。

总之，虽然这看起来像是一个数学谬误，但对于 C++ 和计算机来说，这种说法是正确的。

如何解决 C++ 中的比较问题

C++ 和其他大多数编程语言在逻辑比较方面使用了与传统数学不同的语法。数学表达式 3 < a < 15 的意思是“ 3 小于 a 且 a 小于 15”。然而，正如你所看到的，C++ 对这个表达式的解释是不同的。

要在 C++ 中表示“and”，可以使用“&&”运算符。然后，您可以将布尔表达式链接在一起，并使用像“&&”表示 AND，“||”表示OR和“！”表示 NOT 等运算符构建逻辑。像 Java 这样的语言使用相同的逻辑运算符。

使用正确的逻辑运算符，可以修复前面示例中的错误：

#include 
int a = 15;

int main()
{
    if (3 < a && a < 10)
    {
	std::cout << "foo" << std::endl;
    }
    else
    {
	std::cout << "boo" << std::endl;
    }
    
    return 0;
}

现在这段代码将测试 a 值是否大于 3 以及 a 值是否小于 10。编译并运行程序并观察结果。

前面的例子输出了“foo”，但现在程序输出了预期的“boo”。比较的左侧（3 < a）的布尔值为true。右侧的值（a < 10）为false。由于true和false始终是false，因此整个表达式的结果为false，因此条件失败，else块运行。

提示：你也可以尝试将 AND (&&) 运算符切换为 OR (||) 并观察不同的结果。

在 C++ 中逻辑检查的重要性

在C++中，逻辑比较涉及使用布尔值和比较运算符。确保使用正确的布尔值和比较运算符来控制程序的运行。因为C++通常不会完全失败，而是执行不同的行为，所以很难发现格式不正确的表达式。

现在您知道编译器如何忽略这个问题，并在从左到右读取每个比较时将其视为布尔值。在使用任何语言时都要注意这个问题，并学会识别其影响，以便提前一步。

The post 在 C++ 中比较数字时要小心 first appeared on Linux迷.

C# 专家：有经验的开发者必须掌握的三个高级特性

linuxmi — Sat, 25 Mar 2023 23:39:31 +0000

C# 就像约会一样，既令人沮丧又充满回报。在我作为一名 C# 开发人员的经历中，我被高水平的程序员所包围，他们推动我认识到在这个行业中取得成功需要付出多大的努力。

本文将介绍 3 个高级的、必须掌握的 C# 特性，这些特性将让您成为一个编程专家，并将您的面向对象编程和 C# 技能提升到新的高度。

1、LINQ（语言集成查询）：简单来说，这是一组工具，可以方便地操作可枚举类型（例如 List、Dictionary 等）的数据。这个工具包括基于预设的 predicates/requirements 的方法来修改变量：

using System;
using System.Collections.Generic;
using Systems.Linq;

public class LinqMethodExample
{
  public static void Main(string[] args)
  {
    // 创建一个整数列表。
    var listOfNumbers = new List { 10, 5, 20, 15, 30, 25, 33, 66 };
    
    // 执行各种LINQ方法。
    var result = listOfNumbers
      .Where(num => num % 5== 0)             // 得到可被5整除的数字。
      .Select(num => (int)Math.Pow(num, 2))  // 将每个数字平方。
      .Skip(1)                               // 跳过第一个元素。
      .Last(num => num % 2 == 0)             // 得到最后一个偶数。
    
    Console.WriteLine($"{result}");

    // 样例输出：
    // 900
  }
}

还有其他方法，比如：

OrderBy() -> 根据谓词按升序对序列进行排序。
GroupBy() -> 根据谓词对元素进行分组。
SelectMany() -> 扁平化嵌套列表（即从 List> 提取 List）。
Join() -> 根据谓词连接两个序列。
Zip() -> 将两个序列组合成元组的单个序列。
Distinct() -> 从序列中返回不同的元素。

这只是一个简单的示例，展示了 LINQ 方法的强大之处。这些方法的可扩展性和应用取决于您作为一名工程师的决策。在 LINQ 库中存在许多更多的方法。

2、异步编程: 这是一种简单的技术，允许程序在不阻塞主线程的情况下运行多个不同过程的任务。

与等待任务完成不同，异步任务允许其他任务同时继续执行。这有助于提高应用程序的响应性和性能，通常可以使用 async 或 await 关键字来实现。下面的代码以异步方式执行三个任务。也就是说，如果编译此代码，您将看到这三个任务将同时运行，并在不同的时间完成：

using System;
using System.Threading.Tasks;

public class AsyncProgramming
{
  public static async Task RandomDelayAsync(int workId)
  {
    // 为此给定任务设置一个随机延迟值（1s-5s）。
    var rand = new Random();
    var delay = rand.Next(1000, 5000);
    await Task.Delay(delay);

    // 打印消息，以便用户知道此任务何时完成。
    Console.WriteLine($"Work {workId} completed in {delay}ms.");
  }

  public static async Task Main()
  {
    // 创建一个由3个任务组成的数组以异步执行。
    var tasks = new Task[3];

    for (var idx=0; idx < tasks.Length; idx++)
    {
      tasks[idx] = RandomDelayAsync(idx);
    }

    // 等待所有任务完成。
    await Task.WhenAll(tasks);
    Console.WriteLine("All tasks completed.");

    // 示例输出:
    // Work 2 completed in 1014ms.
    // Work 0 completed in 2329ms.
    // Work 1 completed in 4392ms.
    // All tasks completed.
  }
}

3、委托和事件: 简单来说，这些工具提供了一种定义回调方法签名的方式，并提供了一种将事件处理程序附加/分离到事件的方式。

换句话说，委托就像你给别人的电话号码，事件就像通话后出现的语音邮件。当事件发生时，它是由电话号码通话引起的，代码会响应并做出相应的操作，比如触发一个语音邮件：

using System;

public class DelegateAndEventExample
{
    // 声明表示方法的委托类型
    // 不接受任何参数并返回void。
    public delegate void PhoneNumber();

    public class Class
    {
        // 声明类型为PhoneNumber的事件。
        public event PhoneNumber VoiceMail;

        // 定义引发事件的方法。
        public void CallPhoneNumber()
        {
            Console.WriteLine("Calling the phone number...");
            MyEvent?.Invoke();
        }
    }

    public static void Main()
    {
        var instance = new MyClass();

        // 使用lambda表达式将方法附加到语音邮件事件。
        instance.VoiceMail += () => Console.WriteLine("Event handler called!");

        // 调用CallPhoneNumber方法，该方法会引发语音邮件事件。
        instance.CallPhoneNumber();

        // 示例输出:
        // Calling the phone number...
        // Event handler called!
    }
}

总之，掌握 LINQ、异步编程和委托/事件对于经验丰富的 C# 开发人员来说是必不可少的，他们的目标是提高编码技能。通过利用这些强大的功能，开发人员可以编写更高效、简洁和灵活的代码，轻松处理复杂操作。因此，如果您是一个 C# 专家或渴望成为一个专家，一定要将这些功能添加到您的工具箱中，并将您的编码水平提升到更高的水平。

The post C# 专家：有经验的开发者必须掌握的三个高级特性 first appeared on Linux迷.

释放 C++ 中 Lambda 表达式的强大威力

linuxmi — Thu, 23 Mar 2023 08:30:28 +0000

Lambda 是 C++ 中的匿名函数（即没有函数名的函数），可以在定义和使用时内联。它们提供了一种方便的方式，将小的代码块作为参数传递给其他函数，或者在不需要创建命名函数的情况下定义一个函数。

Lambda 在 C++ 中提供了一种灵活而简洁的方式来编写类似函数的对象，并在现代 C++ 编程中被广泛使用。

Lambda 的定义使用以下语法：

[ capture list ] ( argument list ) -> return type { function body }

捕获列表（capture list）用于指定 lambda 中可访问的来自外部作用域的变量。变量可以通过值捕获、引用捕获或使用 this 捕获。
参数列表（argument list）指定将递给 lambda 的参数。
返回类型（return type）指定 lambda 将返回的值的类型。如果未指定，则编译器将尝试推断其类型。
函数体（function body）指定 lambda 被调用时将执行的代码。

以下是在C++中使用 lambda 的几种不同方式：

函数回调（Function Callbacks）
默认捕获（Capturing default）
值捕获（Capturing by value）
引用捕获（Capturing by reference）
可变 lambda（Mutable Lambdas）

1、函数回调

函数回调是将一个函数作为参数传递给另一个函数，并在接收函数稍后的时间调用该函数。您可以将 lambda 作为函数参数传递，其中它将在发生某个事件时执行。

示例：

#include 
#include 
#include 

int main() {
  std::vector numbers = {1, 2, 3, 4, 5};

  // Lambda 表达式，用于查找两个数字的和
  auto sum = [](int a, int b) { return a + b; };

  int result = std::accumulate(numbers.begin(), numbers.end(), 0, sum);
  std::cout << "Sum of elements in the vector: " << result << std::endl;

  return 0;
}

在这个例子中，sum 变量是一个Lambda表达式，它接受两个参数 a 和 b，并返回它们的总和。std::accumulate 函数接受数字向量、结果的初始值和 sum 函数（Lambda 表达式）。该函数计算向量中所有元素的总和并返回结果，该结果被打印在屏幕上。

另一个例子：

#include 
#include 
#include 

int main()
{
    std::vector vec = { 1, 2, 3, 4, 5 };
    int sum = 0;
    std::for_each(vec.begin(), vec.end(), [&sum](int x) { sum += x; });
    std::cout << "The sum is: " << sum << std::endl;
    return 0;
}

在这种情况下，lambda 表达式 [&sum](int x) { sum += x; } 被传递作为要应用于每个元素的函数。lambda 通过引用 & 捕获变量 sum，以便可以在 lambda 主体中进行修改。

两个例子都达到了相同的结果，但第二个例子使用了 std::for_each 算法和 lambda 表达式，这是在 C++ 中更现代、更简洁的技术。

2、默认捕获

当一个 lambda 表达式被声明时没有任何显式的捕获，其默认行为是通过引用捕获周围作用域中的变量。这被称为默认捕获。

例子：

#include 

int main() {
  int x = 42;
  auto f = [ ]() { std::cout << x << std::endl; };
  f();
  return 0;
}

#include 

int main()
{
    auto square = [](int x) { return x * x; };
    std::cout << "The square of 5 is: " << square(5) << std::endl;
    return 0;
}

在第二个例子中，定义了一个 lambda 表达式并将其存储在名为 square 的变量中。这个 lambda 表达式接受一个 int 类型的参数 x，并返回 x * x 的值，即参数的平方。

在主函数中，这个 lambda 表达式被用作函数对象。通过传递一个值为 5 的参数来调用它，并使用 cout 流显示结果。

3、按值捕获

这是 lambda 表达式的最简单形式，其中你通过值传递变量给函数。当一个变量被按值捕获时，它的当前值被存储在闭包中，而当周围作用域中的变量发生改变时，它的值不会被更新。这可以通过将变量包含在方括号 [ ] 中来实现。

例子：

#include 

int main() {
  int x = 42;
  auto f = [x]() { std::cout << x << std::endl; };
  f();
  return 0;
}

#include 

int main() {
    int x = 42;
    auto f = [x](int y) { std::cout << x+y << std::endl;};
    f(1);
    return 0;
}

4、按引用捕获

你可以通过使用 & 符号将变量传递给 lambda 表达式来按引用捕获变量。当一个变量被按引用捕获时，它的当前值被存储在闭包中，并且在周围作用域中变量发生变化时被更新。这是通过在方括号[ ]中在变量前加上取地址运算符 & 来实现的。

例子：

#include 

int main() {
  int x = 42;
  auto f = [&x]() { std::cout << x << std::endl; };
  f();
  return 0;
}

#include 

int main() {
  int x = 10;

  auto add_one = [&x]() { ++x; };
  add_one();
  std::cout << x << "\n";

  return 0;
}

#include 

int main() {
  int x = 42;
  auto f = [&x]() { std::cout << x << std::endl; };
  f();
  return 0;
}

5、可变Lambda表达式

默认情况下，由 lambda 表达式捕获的变量是常量，不能在 lambda 表达式体内修改。如果你想要在 lambda 表达式中修改捕获的变量，你可以将 lambda 表达式设为可变。可变lambda允许捕获的变量被修改。这是通过在方括号 [ ] 中包含可变关键字来实现的。

例子：

#include 

int main() {
  int x = 42;
  auto f = [x]() mutable { std::cout << ++x << std::endl; };
  f();
  return 0;
}

lambda 表达式类似于普通函数，但它们有一些关键的区别。例如，lambda 表达式的类型没有被显式指定，但可以由编译器推断出来。此外，lambda 表达式可以从周围的作用域中捕获变量，这使得它们非常适用于创建闭包和在 C++ 中使用函数式编程概念。

与传统函数相比，lambda 表达式具有一些性能优势：

内联函数：编译器会自动将 lambda 表达式内联，这意味着它们的代码直接插入到调用函数中。这可以减少函数调用的开销并提高性能。
避免命名函数的开销：lambda 表达式没有名称，因此它们不必被声明和存储在符号表中，这可以减少开销并提高性能。
改善高速缓存局部性：lambda 表达式可以在同一个函数中定义和使用，这意味着lambda使用的代码和数据将存储在与调用代码相同的高速缓存行中。这可以改善高速缓存局部性并降低高速缓存失效的成本。
减小代码大小：lambda 表达式通常比命名函数小，并且它们不需要外部函数调用，这可以减小编译代码的大小并提高性能。
增加灵活性：lambda 表达式可以用来将函数作为参数传递给其他函数，这提供了更大的灵活性，可以改善性能，减少重复代码的需求。
提高可读性：lambda 表达式可以通过以紧凑而自包含的方式封装复杂的逻辑来使代码更易于阅读。这可以通过使代码更易于理解和维护来提高性能。

总之，与传统函数相比，lambdas 可以通过减少开销、提高缓存位置、减少代码大小、提高灵活性和提高可读性来提高性能。

The post 释放 C++ 中 Lambda 表达式的强大威力 first appeared on Linux迷.

C 语言分支结构五题

渔火 — Mon, 13 Feb 2023 11:30:06 +0000

Hi！这里是渔火，今天我们来做有关分支结构的代码题目，每道题都需要用到分支结构。

【1】编写程序，输入有关月份值，输出该月份是第几季度。

【2】根据键盘输入的年、月，输出该年该月的天数。

【3】编写程序，判断输入的年份是否为闰年。

【4】由键盘输入一个3位的整数，判断该数是否位升序数。如果输入的不是3位数，输出“输入错误”。升序是指高位数依次小于其低位数。

【5】编写程序，输入一个整数，判断它是奇数还是偶数。