显然，我们可以在一个constexpr函数中连接两个字符串文字，但是如何将一个字符串文字与另一个constexpr函数返回的字符串连接起来，如下面的代码所示？
template <class T>
constexpr const char * get_arithmetic_size()
{
switch (sizeof(T))
{
case 1: return "1";
case 2: return "2";
case 4: return "4";
case 8: return "8";
case 16: return "16";
default: static_assert(dependent_false_v<T>);
}
}
template <class T>
constexpr std::enable_if_t<std::is_arithmetic_v<T>, const char *> make_type_name()
{
const char * prefix = std::is_signed_v<T> ? "int" : "uint";
return prefix; // how to concatenate prefix with get_arithmetic_size<T>() ?
}
static_assert(strings_equal(make_type_name<int>, make_type_name<int32_t>);
该代码使算术类型的与编译器无关的字符串标识符。
编辑1：
稍微复杂一点的例子是：
template<typename Test, template<typename...> …据我从这篇文章中了解到，ChimeraModule当我在干净的模拟器上启动我的应用程序时，有一些模块会定期关闭我的应用程序。我有onApplicationStateChanged将应用程序状态保存到文件的 QT 事件处理程序，但在这种情况下没有调用它，因此应用程序状态丢失。
在这种情况下保存我的数据的正确点是什么？
应用日志包含以下内容：
D MyApp : onApplicationStateChanged(Qt::ApplicationActive)
...
I ChimeraModuleLdr: Module config changed, forcing restart due to module com.google.android.gms.ads.dynamite
I Process : Sending signal. PID: 7442 SIG: 9
当我切换到另一个应用程序（或停用该应用程序）时，也会出现
D MyApp : onApplicationStateChanged(Qt::ApplicationInactive)
D MyApp : onApplicationStateChanged(Qt::ApplicationSuspended)
在日志中并保存应用程序状态。
我有一个简单的容器：
template <class T, class Allocator = std::allocator<T>>
class ring
{
public:
using value_type = T;
using allocator_type = Allocator;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using reference = T &;
using const_reference = const T &;
using pointer = T *;
using const_pointer = const T *;
private:
template <class E>
class ring_iterator
{
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = E;
using difference_type = std::ptrdiff_t;
using reference = E &;
using pointer = E *; …下面的代码什么时候发生内存释放？
#include <memory>
int main()
{
auto p = std::make_shared<int>(5);
std::weak_ptr<int> wp = p;
p = nullptr;
return wp.lock() == nullptr ? 0 : 1;
}
如下从这篇文章 std::make_shared执行一个堆分配。这是否意味着在至少有一个std::weak_ptr存活之前，内存不能被释放？
我的应用程序在Android 10具有以下调用堆栈的设备上崩溃：
backtrace:
#00 pc 000000000006f06c /apex/com.android.runtime/lib64/bionic/libc.so (abort+160)
#01 pc 00000000000500fc /system/lib64/libc++.so (abort_message+232)
#02 pc 0000000000050218 /system/lib64/libc++.so (demangling_terminate_handler()+44)
#03 pc 00000000000646c4 /system/lib64/libc++.so (std::__terminate(void (*)())+12)
#04 pc 000000000006466c /system/lib64/libc++.so (std::terminate()+52)
#05 pc 00000000000bb150 /system/lib64/libc++.so (std::__1::thread::~thread()+20)
#06 pc 00000000000d0f48 /apex/com.android.runtime/lib64/bionic/libc.so (__cxa_finalize+212)
#07 pc 00000000000cc930 /apex/com.android.runtime/lib64/bionic/libc.so (exit+24)
#08 pc 0000000000032f30 /data/app/com.domain.myapp-Rs_sm5VrLR1Jj8QW6oYByA==/lib/arm64/libplugins_platforms_qtforandroid_arm64-v8a.so
我不知道什么时候以及为什么会发生这种情况，因为我无法在我的设备和模拟器上重现这一点，但这在用户端集中发生，并且只发生在Android 10（不是在以前的 Android 版本上）。
我的QT版本是 5.14.2。
为什么下面的代码不能编译？
#include <stdint.h>
#include <array>
class A
{
struct Helper
{
static constexpr uint64_t p2(uint8_t n)
{
return static_cast<uint64_t>(1) << n;
}
};
using DenomArray = std::array<uint64_t, Helper::p2(5)>;
};
使用 GCC 我得到：
error: 'static constexpr uint64_t A::Helper::p2(uint8_t)' called in a constant expression before its definition is complete
我的理解是p2应该定义函数，因为Helper类是完全编译的。
为 x86 和 GCC 12 尝试了 MSVC 编译器版本 19.29.30040。
编辑1：
模板和非模板类的行为不同。例如下面的代码编译：
template <class T>
class A
{
private:
struct Helper
{
static constexpr T p2(uint8_t n)
{
return …据我所知，下面的代码是正确的：
#include <iostream>
#include <functional>
struct A
{
std::function<void ()> func;
int value = 5;
~A() { func(); }
};
int main()
{
A* p_a = new A();
p_a->func = [&p_a]() { std::cout << p_a->value; };
delete p_a;
return 0;
}
但以下代码不是并导致分段错误：
#include <memory>
int main()
{
std::unique_ptr<A> p_a = std::make_unique<A>();
p_a->func = [&p_a]() { std::cout << p_a->value; };
p_a = {};
return 0;
}
std::unique_ptr 首先清除其内部指针，然后删除该对象，从而防止访问被销毁的对象。
它是做什么用的？这背后的逻辑是什么？
将下面的结构转换为的正确方法是什么uint64_t？
struct Data
{
uint64_t sign : 1;
uint64_t exp : 4;
uint64_t man : 8;
};
static_assert(sizeof(Data) == sizeof(uint64_t));
显而易见的是
Data data;
uint64_t n = *(reinterpret_cast<const uint64_t*>(&data));
但它不会编译为constexpr并在 GCC 中产生以下警告：
dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
编辑1：
result 的值uint64_t可能因编译器不同而不同。但是当我将它从uint64_t.
所以，更准确地说我需要：
Data data;
uint64_t n = convert(data);
Data data2 = convert_back(n);
static_assert(data == data2);
下面的代码不能同时编译 MSVC2017 和 GCC11：
#include <deque>
#include <chrono>
#include <algorithm>
using Clock = std::chrono::system_clock;
using TimePoint = std::chrono::time_point<Clock>;
struct PricePoint
{
TimePoint dt;
double buy;
double sell;
};
inline bool operator < (const TimePoint & dt, const PricePoint & a)
{
return a.dt < dt;
}
int main()
{
std::deque<PricePoint> priceSequence;
const auto begin = std::lower_bound(priceSequence.begin(), priceSequence.end(), Clock::now());
return 0;
}
但是如果我std::lower_bound用std::upper_bound它替换它开始编译。有什么不同？
我找到了一篇关于如何创建递归 lambda的帖子，但不清楚如何从函数中返回它。
据我所知，在下面的代码中，捕获func是指被销毁的对象：
#include <iostream>
#include <functional>
std::function<int (int)> make_lambda()
{
std::function<int (int)> func;
func = [&func](int val)
{
if (val < 10)
{
return func(val + 1);
}
return val;
};
return func;
}
int main()
{
std::cout << make_lambda()(0);
return 0;
}
如何使这段代码工作？
有没有比使用更好的方法std::shared_pointer<std::function<int (int)>>？
void make_lambda(std::function<int (int)>&) 不是一个选择。
编辑1：
为什么this不允许 lambdas 引用自己？
下面的示例不会崩溃，但使用 MSVC 编译器版本 19.32.31332 不打印任何内容，并使用 GCC 打印“def”：
#include <string>
#include <vector>
#include <set>
#include <ranges>
#include <iostream>
template <class R, class Value>
concept range_over = std::ranges::range<R> &&
std::same_as<std::ranges::range_value_t<R>, Value>;
const std::string& find1(const std::vector<std::string>& v)
{
return v[1];
}
template <range_over<std::string> Range>
std::reference_wrapper<std::string> find2(Range range)
{
return *(range.begin() + 1);
}
int main()
{
std::vector<std::string> v = { "abc", "def", "ghi" };
//find1 always prints "def"
//std::cout << find1(v);
std::cout << find2(v).get() << std::endl;
return 0;
}
但在我的现实应用程序中，类似的代码会因 MSVC 编译器版本 19.32.31332 …
我有一个带有异步printInfo方法的Bot类：
class TradeBot {
async printInfo() { //..... }
}
如果我启动“节点”，请从控制台创建对象并调用该方法：
>const createBot = require ('./BotFactory');
>const bot = createBot();
>bot.printInfo();
控制台中会出现一个令人讨厌的额外信息：
Promise {
<pending>,
domain:
Domain {
domain: null,
_events: { error: [Function: debugDomainError] },
_eventsCount: 1,
_maxListeners: undefined,
members: [] } }
有没有办法抑制它？
'await'关键字在这里产生错误。