标签: standards

假设我有一个依赖两个模块的脚本：

• 主要.py
• 模块1.py
• 模块2.py

只会执行Main.py，但是在Main的执行过程中，有多次调用Module1.py和Module2.py内部的方法。

是不是比较常见...

1）将所有内容记录到 Main.py 的日志中？

或者

2）将每个操作各自模块的所有内容记录到日志中？

（tl；博士，如果您理解我的问题，则无需继续阅读。否则，这是一个示例）：

示例（使用非常简短的代码）：

案例 #1只有一个日志文件，我们将其称为 Main.log。假设记录器名称没有硬编码（尽管在本例中是这样），所以我应该制作 AnotherMain.py ，例如，所有日志条目都将进入 AnotherMain.log

主要.py：

some_value = Module1.get_value("abc")
some_other_value = Module2.get_value("def")
some_result = some_value + some_other_value
log("main", "some_result evaluated successfully")

模块1.py：

def get_value(key):
   ...
   log("main", "returning value for key from Module1")

模块2.py：

def get_value(key):
   ...
   log("main", "returning value for key from Module2")

这将导致 Main.log 读取：

some_result evaluated successfully
returning value for key from Module1
returning value for key from Module2

案例 #2有三个日志文件，每个模块一个：Main.log、Module1.log、Module2.log。

主要.py： …

我正在尝试学习 C++，以前没有使用过 C++ 或 C，而且我发现一些培训材料有时试图教我 C 编码而不是 C++。

由于我没有足够的知识来辨别这些书是否试图教我正确的 C++，我想我可以在 g++ 编译器上设置一些参数来解决这个问题。所以我的问题是：

如何在Windows中设置g++编译器，以便如果我写的不是纯C++标准，他就不会编译？

提前谢谢了

下面的代码摘自cppref：

#include <string>

using namespace std::literals;

template<typename T>
concept bool EqualityComparable = requires(T a, T b)
{
    {
        a == b
    }
    ->bool;
};

void f(EqualityComparable&&) {}

int main()
{
    f("abc"s);
}

然而，它不能用 clang-10 编译：

[root@mine ~]# clang++ -std=c++20 -stdlib=libc++ main.cpp
main.cpp:6:14: warning: ISO C++20 does not permit the 'bool' keyword after 'concept' [-Wconcepts-ts-compat]
concept bool EqualityComparable = requires(T a, T b)
        ~~~~~^
main.cpp:11:7: error: expected concept name with optional arguments
    ->bool;
      ^
main.cpp:14:8: error: unknown type name …

我在 C 和 C++ 上编程已经有一段时间了，并且总是确信双除 int 会得到 double，或者双除 int 也会得到 double（只有 int 除以 int 才会得到 int），并且与加法相同。我正在做我的作业，并确信1 + (f*f + 10) / k, where fisdouble和kisint总是返回双倍。我在mac上使用g++ -std=gnu++11命令（所以它可能是clang编译器）并且我通过了测试（结果我确实得到了浮点数），但我的老师说它不确定它是否是浮点数（他使用的是windows）。该行为平台特定吗？是否有任何 C++ 标准描述 int 除法上的 double ？谢谢你！我的代码：

#include <iostream>
using namespace std;

int main() {
    int  N;
    double f, P = 0;
    cin >> N >> f;
    for (double k = 1; k <= N; k++){
      P += 1 + (f*f + 10) / k; …

我学习 C++ 一段时间了，对它的容器用法感到困惑。如果我想使用某个容器，我必须手动将它们一一包含在内。例如，如果我想使用“向量”容器，我必须输入#include "vector"，如果我稍后需要“列表”容器，我必须添加#include "list"。

为什么 C++ 标准不简单地将每个容器类放在一个头文件中（例如 ）#include "container"，这样开发人员就不用关心将它们一一包含了？

鉴于intptr_t是可选的并且ptrdiff_t是强制性的，将p - nullptr是 的一个很好的替代品，从用with而不是?(intptr_t)p表示的结果转换回来。它在定义的实现上在语义上与 IIUC 等效，但也按其他方式工作。nnullptr + n(decltype(p))nintptr_t

如果我的上述说法是正确的，为什么该标准不允许不实施intptr_t？看来由此提供的自由并不是特别有价值，只是需要削减一组两个简单的本地源代码转换（或优化的等效项）。

后续问题是： 如何检测非 IEEE-754 浮点，以及如何使用它们？

理论上，我们可以假设 c float 总是支持负数吗？

我遇到了一些 C++20 代码的问题，这些代码在发行版（-O3、clang 15）中编译时崩溃，并且由于在最终可执行文件上应用了许多混淆技术，因此调试起来非常棘手。很难看到实际执行的 x86_64 ASM。

尽管如此，我还是设法将崩溃范围缩小到以下伪代码......

for (std::wstring& data : datas)
{
    auto id = std::format(L"foo_{0}", data);

    do_something(id, std::move(data));
}

...其中的签名do_something如下所示：

void do_something(const std::wstring&, std::wstring);

std::wstring基本上，我认为在设置调用时应该已经调用第二个参数的移动构造函数。

现在，这段代码在 -O2 下工作得很好，但是当启用 -O3 时它就崩溃了，我有一种预感。

通读C++标准，我们可以看到以下内容......

任何表达式的任何部分的求值顺序（包括函数参数的求值顺序）均未指定（下面列出了一些例外情况）。编译器可以按任意顺序计算操作数和其他子表达式，并且在再次计算同一表达式时可以选择其他顺序。

我还读到，当 C++ 编译器没有副作用时，它们可以自由地优化局部变量（但尚未在标准中找到此特定规则）。

难道是因为std::format上面的代码本身没有副作用，所以编译器在使用 -O3 时将其“内联”到函数调用中？当它发生时，评估的顺序是未定义的，因此移动实际上发生在调用 to之前std::format？

基本上我要问的是：C++ 标准允许我描述的优化吗？

我正在阅读有关 C 的 K&R 书的介绍部分。为了查看哪种代码格式会产生错误，我尝试分成printf("hello world!");不同的行，如下所示。问题是，我不知道我的结果是否与实现无关。我用的是GCC编译器。

C 标准对多行表达式有何规定？编译器如何处理它们？

/*
    printf("hello wor
    ld!\n");
*/

/*
    printf("hello world!
    \n");
*/

    printf("hello world!\
    n");

/*
    printf("hello world!\n
    ");
*/

    printf("hello world!\n"
    );

    printf("hello world!\n")
    ;

注释掉的表达式会产生错误，而其余的则不会。

第三个表情的行为出乎意料。通常"需要在同一行终止，但第三个表达式可以工作。

第三个表达：

    printf("hello world!\
    n");

输出到控制台：

hello world!    n

似乎\可以用于将字符串拆分为多行，但前面的空格n");被包含为字符串的一部分。这是标准规则吗？

考虑以下代码：

#include <type_traits>

template<typename T>
struct A1 {
    T t;

    // implicitly-declared default constructor
};

template<typename T>
struct A2 {
    T t;

    // explicitly-declared default constructor without noexcept
    A2() = default;
};

template<typename T>
struct A3 {
    T t;

    // explicitly-declared default constructor with noexcept
    A3() noexcept(std::is_nothrow_default_constructible<T>::value) = default;
};

这三个默认构造函数在 C++ 中等效吗？