标签: implicit-conversion

有符号和无符号之间的比较。static_cast 是唯一的解决方案吗?

我使用第三方容器int来存储大小。我还使用 stl 容器size_t来存储大小。

我经常在我的代码中必须在同一个循环中使用两者,例如:

// vec is std::vector
// list is the third party container
assert(vec.size() == list.size()); // warning
for(size_t i = 0; i < vec.size(); i++)
{
    vec[i] = list[i]; // warning
}
Run Code Online (Sandbox Code Playgroud)

因此,为了解决这个问题,我必须要么进行函数风格转换,有人告诉我这是变相的 C 风格转换。

// vec is std::vector
// list is the third party container
assert(int(vec.size()) == list.size());
for(size_t i = 0; i < vec.size(); i++)
{
    vec[i] = list[int(i)];
}
Run Code Online (Sandbox Code Playgroud)

或者我可以采用每个人都推荐的更丑陋的解决方案。静态铸造。

// vec is std::vector
// list is the third party …
Run Code Online (Sandbox Code Playgroud)

c++ static-cast implicit-conversion c++11

5
推荐指数
1
解决办法
1064
查看次数

为什么我会收到 Wsign 转换警告?

我有以下代码:

template <typename T>
struct wrapper {
    T t;
    operator T() { return t; }
    T get() { return t; }
};

int main() {
    int a[10];
    int* x = a;
    wrapper<long unsigned int> y{2};
    std::cout << (x + y); // warning
}
Run Code Online (Sandbox Code Playgroud)

当我在 gcc 上编译它(在 7.3.0 和 8.2.0 上测试)时,-Wsign-conversion我收到“警告:从‘long unsigned int’转换为‘long int’可能会改变结果的符号”。如果y有 type long unsigned int,则没有警告。此外,当我明确调用时y.get()也没有警告:

std::cout << (x + y.get()); // this is ok
Run Code Online (Sandbox Code Playgroud)

为什么会出现这种情况呢?使用用户定义的转换时,是否有一些不能使用的指针算术特殊规则?

c++ gcc type-conversion implicit-conversion c++11

5
推荐指数
1
解决办法
2945
查看次数

为什么 Tensorflow 将 int32/int32 转换为 float64 以及如何停止它?

我将 int32 类型的张量除以 int32 类型的张量,结果是 float64。我找不到关于为什么会发生这种情况的答案,或者 Tensorflow 如何执行此操作背后是否存在隐含规则。我还没有为任何张量明确定义 dtype,但我已经检查了所有张量,并且在除法之后它们都没有 64 位类型。

我尝试过使用不同的除法公式,例如 tf.divide,都给出相同的结果。

我的代码如下所示:

a_cdf = a / tf.size(a)
Run Code Online (Sandbox Code Playgroud)

具有 tf.int32 类型。

我想要得到的是 float32 形式的结果,这样我就可以编写我的函数而无需显式转换。

implicit-conversion tensorflow

5
推荐指数
1
解决办法
2170
查看次数

使用模板在 size_t 和 int 之间进行隐式类型转换

我有这个编译时序列生成类(取自此处,并对其进行了一些修改):

#include <cstddef>

template <int...>
struct sequence {};

template <int... Ns>
struct generator;

template <std::size_t Count, int... Ns>  // XXX (read below)
struct generator<Count, Ns...> {
    using type = typename generator<Count - 1, Count - 1, Ns...>::type;
};

template <int... Ns>
struct generator<0, Ns...> {
    using type = sequence<Ns...>;
};

template <std::size_t N>
using sequence_t = typename generator<N>::type;

int main() {
    sequence_t<5> a;
    return 0;
}
Run Code Online (Sandbox Code Playgroud)

这在 Visual Studio 下编译得很好(即使使用/permissive-开关)。但在 GCC 下会抛出错误:

#include <cstddef>

template <int...> …
Run Code Online (Sandbox Code Playgroud)

c++ template-specialization language-lawyer implicit-conversion variadic-templates

5
推荐指数
1
解决办法
165
查看次数

Scala 3 隐式转换:比较值和文字

我有一个不透明类型,它是通过在伴生对象范围中FancyDouble使用从 Double 隐式转换的。given Conversion[Double, FancyDouble] = FancyDouble(_)之后,构造val d: FancyDouble = 0.0工作,但是当我尝试进行类似的比较时if (d == 0.0),编译器抱怨我无法比较FanceDoubleand Double(我期望它应该将0.0文字隐式转换为 FancyDouble,就像前面的情况一样。

如何启用与隐式转换的比较?

scala implicit-conversion scala-3

5
推荐指数
1
解决办法
203
查看次数

pybind11implicitly_convertible 不起作用

我正在努力使最简单的示例发挥作用。这是我的代码:

// example.cpp

#include <pybind11/pybind11.h>
namespace py = pybind11;

class B {
public:
    int b;
};

class A {
public:
    int a;
    A(int a) :a(a) {}
    A(B b) { a = b.b; }
};

void fn(A) {}

PYBIND11_MODULE(example, m) {

    py::class_<A>(m, "A")
        .def(
            py::init<int>(),
            py::arg("a") = 1
        );

    py::class_<B>(m, "B")
        .def(
            py::init<int>(),
            py::arg("b") = 2
        );

    py::implicitly_convertible<A, B>();

    m.def("fn", &fn,
        py::arg("a")
    );
}
Run Code Online (Sandbox Code Playgroud)
# test.py

from example import *

a = A()
b = B()

fn(b)
Run Code Online (Sandbox Code Playgroud)

它构建得很好,但输出是:

$ python3.9 test.py …
Run Code Online (Sandbox Code Playgroud)

implicit-conversion pybind11

5
推荐指数
1
解决办法
916
查看次数

C/C++编译器如何区分常规二维数组和数组指针数组?

常规静态分配数组如下所示,可以使用以下公式进行访问:

const int N = 3;
const int M = 3;

int a1[N][M] = { {0,1,2}, {3,4,5}, {6,7,8} };

int x = a1[1][2]; // x = 5 
int y = *(a1+2+N*1); // y = 5, this is what [] operator is doing in the background
Run Code Online (Sandbox Code Playgroud)

数组是连续的内存区域。在动态数组分配的情况下看起来有所不同,而是有指向数组的指针数组:

int** a2 = new int*[N];
for (int i = 0; i < N; i++) 
   a2[i] = new int[M];

//Assignment of values as in previous example

int x = a2[1][2];
int y = *(*(a2+1))+2); // …
Run Code Online (Sandbox Code Playgroud)

c c++ pointer-arithmetic multidimensional-array implicit-conversion

5
推荐指数
1
解决办法
196
查看次数

指向成员的指针访问运算符的行为差异

在 C++ 中,我正在寻找标准的关键部分\n解释我在该语言的两个指向成员的指针访问运算符之间观察到的行为的细微差别,.*以及->*。

\n

根据下面显示的我的测试程序,虽然->*似乎允许其\n右手表达式是任何类型隐式转换为 \n pointer to member of S,.*但事实并非如此。当使用 ngcc 和 clang 进行编译时,两个编译器都会对标记为 \'(2)\' 的行产生错误,表明我的类Offset不能用作成员指针。

\n

测试程序\n https://godbolt.org/z/46nMPvKxE

\n
#include <iostream>\n\nstruct S { int m; };\n\ntemplate<typename C, typename M>\nstruct Offset\n{\n    M C::* value;\n    operator M C::* () { return value; }  // implicit conversion function\n};\n\nint main()\n{\n    S s{42};\n    S* ps = &s;\n    Offset<S, int> offset{&S::m};\n\n    std::cout << ps->*offset << \'\\n\';  // (1) ok\n    std::cout << s.*offset …
Run Code Online (Sandbox Code Playgroud)

c++ pointer-to-member language-lawyer implicit-conversion

5
推荐指数
1
解决办法
174
查看次数

为什么较新的编译器开始接受此模板函数调用?

std::atomic_fetch_add()对于低于 9.0 的 x86-64 clang 版本和低于 9.1 的 gcc 版本,以下涉及调用模板函数的小型 C++ 程序无法在 godbolt 中编译,在这两种情况下都使用该--std=c++11选项。

#include <iostream>
#include <atomic>

std::atomic<char> ch ('@');

int main ()
{
    std::atomic_fetch_add (&ch, 5);
    std::cout << ch << std::endl;
}
Run Code Online (Sandbox Code Playgroud)

在那些早期的编译器版本中(它可能与编译器提供的 C++ 库更相关,我不确定),调用std::atomic_fetch_add (&ch, 5); 无法匹配原子获取函数的任何模板专门化,因为chis的类型char和类型是:5​int

:在函数“int main()”中::8:34:错误:没有匹配的函数可调用“atomic_fetch_add(std::atomic*, int)”std::atomic_fetch_add (&ch, 5); ...

但是,更高版本的编译器(和库?)成功编译了此用法。

  1. 是什么改变了这个开始编译?
  2. 如果是标准库更改,则使用什么技术来实现这一点?
  3. C++ 标准(以及什么版本?)是否要求这种用法应该有效。

我几乎是一个 C++ 初学者,但我认为这与在确定要使用的适当模板专业化过程中未执行隐式转换有关。(我可能没有使用精确的语言。)

我知道我可以通过将其重写为来修改对工作的调用

std::atomic_fetch_add<char> (&ch, 5);
Run Code Online (Sandbox Code Playgroud)

或者

std::atomic_fetch_add (&ch, (char)5);
Run Code Online (Sandbox Code Playgroud)

但是,我有兴趣获得一个版本的<atomic>库来支持使用,而无需显式实例化和强制转换。(编译器是 clang 15.0.0,--std=c++11该库是 …

c++ templates implicit-conversion

5
推荐指数
1
解决办法
87
查看次数

为什么编译器无法自动匹配范围基 for 循环中“size_t”变量的类型?

我偶然发现了与range一起operator<<使用时存在不明确重载的问题。\n更具体地说,使用以下代码:std::views::enumeratesize_t

\n
#include <iostream>\n#include <ranges>\nnamespace rv = std::ranges::views;\n\nint main()\n{\n    for (const auto& [idx, value] : rv::iota(0zu, 5zu) | rv::enumerate)\n        std::cout << idx << '\\n';\n}\n
Run Code Online (Sandbox Code Playgroud)\n

并gcc 13.1.1在 Linux 上使用以下命令进行编译:g++ --std=c++23 main.cpp.\n我收到错误:

\n
main.cpp: In function \xe2\x80\x98int main()\xe2\x80\x99:\nmain.cpp:11:19: error: ambiguous overload for \xe2\x80\x98operator<<\xe2\x80\x99 (operand types are \xe2\x80\x98std::ostream\xe2\x80\x99 {aka \xe2\x80\x98std::basic_ostream<char>\xe2\x80\x99} and \xe2\x80\x98std::tuple_element<0, const std::tuple<__int128, long unsigned int> >::type\xe2\x80\x99 {aka \xe2\x80\x98const __int128\xe2\x80\x99})\n   11 |         std::cout << idx << '\\n';\n      |         ~~~~~~~~~ ^~ ~\n      |              | …
Run Code Online (Sandbox Code Playgroud)

c++ implicit-conversion std-ranges c++23

5
推荐指数
1
解决办法
220
查看次数