标签: implicit-conversion

我正在阅读《C++ 如何编程》第 9 版，尝试学习 C++，并尝试使用第 7 章中的骑士问题进行练习。

根据输出中的“64”，代码显然存在某种逻辑错误（我将自行修复），但在执行此操作之前，我一直致力于理解以及如何处理编译器警告。

我已将 board 声明为 unsigned int 的二维数组，因为它只能包含值 0-7。同样，出于同样的原因，我将 for 循环中的变量声明为 unsigned int。

我在 stackoverflow 上读过有关此问题的回复，但它们很快就超出了我的理解范围。

#include <iostream>
#include <array>
#include <iomanip>

using namespace std;

void printArray(const array< array< unsigned int, 8 >, 8 >);

int main() {
  array< array< unsigned int, 8 >, 8 > board = {};
  array< int, 8 > horizontal = {{ 2, 1, -1, -2, -2, -1, 1, 2 }};
  array< int, 8 > vertical = {{ -1, -2, …

我有一种情况，我需要重载解析来更喜欢带有隐式转换的重载而不是同名的模板函数。

考虑以下示例：

#include <iostream>
#include <functional>

void call_function(const std::function<void()>& function)
{
   std::cout << "CALL FUNCTION 1" << std::endl;
   function();
}

template <typename Function>
void call_function(const Function& function)
{
    std::cout << "CALL FUNCTION 2" << std::endl;
    function();
}

int main()
{
    // Pass a lambda to "call_function"
    // This lambda is implicitly convertible to 'std::function<void()>'
    // Even though it is implicitly convertible, the template function is selected by the compiler.
    call_function([]{
        std::cout << "TEST" << std::endl;
    });
}

输出：

CALL FUNCTION …

我正在使用https://cppinsights.io/。以下是代码（默认示例）

#include <cstdio>

int main()
{
    const char arr[10]{2,4,6,8};
    for(const char& c : arr)
    {
      printf("c=%c\n", c);
    }
}

关于cppinsights

C++ Insights 是一个基于 clang 的工具，可以进行源到源的转换。它的目标是让事情可见，这通常是有意地在幕后发生。这是关于编译器为我们做的事情的魔法。或者查看编译器的类。

这是生成的代码，这是编译器如何看待代码

#include <cstdio>

int main()
{
  const char arr[10] = {2, 4, 6, 8, '\0', '\0', '\0', '\0', '\0', '\0'};
  {
    char const (&__range1)[10] = arr;
    const char * __begin1 = __range1;
    const char * __end1 = __range1 + 10L;
    for(; __begin1 != __end1; ++__begin1) {
      const char & c = *__begin1;
      printf("c=%c\n", …

我不确定这个函数指针类型声明语法，但它有效。语法就像声明一个普通的旧函数。

typedef struct Element GetChildCallback(void *userdata, usize parent, usize child_no);

我找不到任何关于它是否符合标准或它可能有哪些缺点的信息。

我认为这仅适用于 typedef，所以我更进一步，发现这也适用于常规函数参数：

extern inline void dmpstrn(const char *t, usize n, int printer(const char *fmt, ...));

inline void dmpstrn(const char *t, usize n, int printer(const char *fmt, ...)) {
    usize len = strlen(t) > n ? n : strlen(t);
    printer("\"");
    for (usize i = 0; i < len; i += 1) {
        if (t[i] == '\n') 
            printer("\\n");
        else
            printer("%c", t[i]);
    }
    printer("\"\n");
}

// ...

int main() {
    dmpstrn("Hello\nworld", UINT64_MAX, …

如果输入数组为空，则array.size()应该为 0。第一个for，从0到array.size() - 1，应该意味着它从0到-1，对吗？

for那么，不应输入此值，并且该函数应返回 inversionsCounter 值，该值将是0

但这并没有发生，代码进入了无限循环。为什么是这样？

这是代码：

#include <vector>
#include <iostream>

using namespace std;

int countInversions(vector<int> array)
{    
    int inversionsCounter = 0;
    for (int i = 0; i < array.size() - 1; ++i)
        for (int j = i + 1; j < array.size(); ++j)
            if (array[i] > array[j])
                ++inversionsCounter;

    return inversionsCounter;
}

int main()
{
    vector<int> array = {};
    cout << array.size();
    cout << …

我想了解如何引用初始化。例如，我们看一个典型的例子。

double val = 4.55;
const int &ref = val;

我可以想到上面代码片段中发生的事情的两种可能性。

可能性1

通常的解释如下：

这里创建了一个带有值类型的临时（纯右值），然后将引用绑定到这个临时（纯右值）对象，而不是直接绑定到变量。发生这种情况是因为右侧变量的类型是，而左侧我们有一个引用。但是为了将引用绑定到变量，类型应该匹配。此外，临时纯右值的生命周期也得到了延长。int4refintvalvaldoubleint