小编Jan*_*tke的帖子

C++-14 引入std::enable_if_t.

它 和 和有什么不一样std::enable_if？使用上有什么优点或者区别吗std::enable_if_t？

我经常使用[0, 1] 范围内的float或double类型。我知道浮点运算是不精确的，所以我通常会限制我的值，以便在运算之前/之后保证它们在这个范围内。

在某些情况下，我依赖浮点数甚至不是轻微的负值，而是完全是<= 1，因此这是必要的。

例如，在这些功能中的任何一个中是否有必要：

// x and y are guaranteed to be in [0, 1]
float avg(float x, float y) {
    // the average of [0, 1] values should always be in [0, 1]
    return std::clamp<float>((x + y) / 2, 0, 1);
}

float mul(float x, float y) {
    // the product of [0, 1] values should always be in [0, 1]
    return std::clamp<float>(x * y, 0, 1);
}

float pow(float x, …

C++14 添加了变量模板，它定义了相关变量组。在标准库中，变量模板用于访问每个类型特征的值成员：

template<class T>
inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;

C++17 添加了内联变量以更好地支持仅头文件库，这些库可以包含在同一应用程序内的多个源文件中（不同的翻译单元中允许相同的内联变量定义）。但就变量模板而言，无论如何它们都可以在程序中具有多个定义。那么，如果变量模板已经免于 ODR，还有什么理由将它们声明为内联呢？

只要很多人都关注constexpr差异inline constexpr，这是另一个有趣的问题，我就想忽略constexpr这次讨论的目的。

template <typename T>
bool myVar = sizeof(T) > 1;

它与以下内容有何不同：

template <typename T>
inline bool myVar = sizeof(T) > 1;

我尝试了这些代码来比较std::copyandstd::string的构造函数。

#include <chrono>
#include <iostream>
#include <vector>

void construct_test() {
  std::vector<uint8_t> raw_data;
  for (int i = 0; i < 1000 * 1024; i++) {
    raw_data.push_back(i % 256);
  }

  auto start = std::chrono::high_resolution_clock::now();
  std::string target_data;
  target_data = std::string(raw_data.begin(), raw_data.end());
  auto finish = std::chrono::high_resolution_clock::now();
  std::cout << "construct: " << std::chrono::duration_cast<std::chrono::microseconds>(finish -
                                                                     start)
                   .count()
            << "us" << std::endl;
}

void copy_test() {
  std::vector<uint8_t> raw_data;
  for (int i = 0; i < 1000 * 1024; i++) {
    raw_data.push_back(i % 256); …

我有一个关于 C++ lambda 的 clang 格式问题。升级到 Clang-Format 15.0.1 后，我注意到短的但不是在线 lambda 的新行为。下面我将它们称为“双行 lambda”。例子：

单行 lambda

// good/unchanged
auto shortLambda= []() { doSomething(); };

两行 lambda：

// unwanted/new behavior
const auto mediumLambda = [some, args, here](More arguments)
{ return doSomething(some, args, here, arguments); };

多线 Lambda：

// good/unchanged
const auto longLambda= [some, args, here](Are here)
{
   auto result =doSomething(some, args, here, arguments); 
   return result;
};

两行 lambda 的期望行为：

// desired
const auto mediumLambda = [some, args, here](More arguments)
{
   return doSomething(some, args, …

我想制作一个NDArray具有固定尺寸的模板，但可以在每个尺寸上调整大小。

我的问题是如何让它能够根据使用了多少对来推断构造函数中的尺寸{}？构造函数中的元素将用于初始化一些元素。

#include <array>
#include <iostream>

template<typename T, size_t Dimension>
class NDArray
{
    T* buffer = nullptr; //flattened buffer for cache locality
    std::array<size_t, Dimension> dimension;    //keep the current sizes of each dimension
public:
    NDArray(std::initializer_list<T> elements) : dimension{elements.size()}   //for 1D
    {
        std::cout << "Dimension = " << Dimension << '\n';
    }
    NDArray(std::initializer_list<NDArray<T, Dimension-1>> list) //how to make this works???
    {
        std::cout << "Dimension = " << Dimension << '\n';
    }
};

template<typename T, size_t N>
NDArray(const T(&)[N]) …

cppreference页面[[assume]]说：

[[assume( expression )]] 

Run Code Online (Sandbox Code Playgroud)

[...] 表达式没有被求值（但它仍然可能被求值）。

这个措辞让我很困惑。这里 cppreference 错了吗？如果不评估，为什么可能会评估？它不是像 中的表达式一样未计算的操作数吗sizeof？如果不可以，后果是什么？

下面的代码在同一个翻译单元中，并且是A::v在之后定义的x，为什么A::v没有初始化为“ok”？

#include <string>
#include <iostream>

std::string foo() {
    return "OK";
}

std::string x = foo();


struct A {
    static inline std::string v = x;
};

int main() {
    std::cout << A::v << std::endl; // didn't print "OK", why?
}

是否可以有一个带有可选模板参数的类，可以像这样调用？：

#include <iostream>

template <typename T = void>
class A final
{
public:
    // This class can be called only when T exists.
    void f()
    {
        printf("%d\n", member);
    }

    // This method can be called only when T is missing.
    void g()
    {
        printf("No template parameter\n");
    }
public:
    T member;
};

int main()
{

    A<int> a1;
    A a2;
    a1.f(); // should be valid
    a1.g(); // should be invalid, cannot compile
    a2.f(); // should be invalid, cannot compile
    a2.g(); // should …

我很困惑。我看到当代码是这样的

void fun(const char **p) { }
int main(int argc, char **argv)
{
   fun(argv);
   getchar();
   return 0;
}

它显示error: invalid conversion from 'char**' to 'const char**'

但是当代码像这样

void test(const char *p) { }
int main()
{
    char *c = new char('a');
    test(c);
}

然后就没有编译错误了。两个代码有什么区别？
为什么第二段代码可以将变量传递给常参数的函数？