标签: implicit-conversion

如何在 C# 中直接键入强制转换装箱结构?

我有一个结构体的命名空间,它代表各种测量单位(米、英尺、英寸等)...总共 12 个,由 T4 模板生成:)。

每个结构体都带有隐式转换运算符以支持将值转换为任何其他测量值类型,因此以下语法是合法的:

var oneThousandMeters = new Meters(1000);    
Kilometers aKilo = oneThousandMeters ;     // implicit cast OK. Value = 1 Km
Run Code Online (Sandbox Code Playgroud)

为了增加乐趣,有一个名为Distance 的包罗万象的类,它可以保存任何测量单位,并且还可以隐式地与测量值进行转换...

var magnum = new Distance(12, DistanceUnits.Inches); 
Feet wifesDelight = magnum;               // implicit cast OK. Value = 1 foot.
Run Code Online (Sandbox Code Playgroud)

遵循 .NET 框架标准,所有字符串格式化和解析均由外部 FormatProvider 处理,该 FormatProvider 实现 ICustomFormatter。遗憾的是,这意味着该值在传递给 Format 方法时会被装箱,并且 format 方法需要针对每个已知的测量类型测试该对象,然后才能对其进行操作。在内部,Format 方法只是将测量值转换为距离值,所以问题来了......

问题:

public string Format(string format, object arg, IFormatProvider formatProvider)
{
    Distance distance;           

    // The following line is desired, but fails if arg …
Run Code Online (Sandbox Code Playgroud)

c# struct implicit-conversion

4
推荐指数
1
解决办法
1万
查看次数

“多个运算符 + 与这些操作数匹配”错误

我正在为学校作业创建一个货币课程。我定义了从 Money 到 double 的转换,我有一个采用 int 的 Money 构造函数,另一个构造函数采用 double,并且我已经重载了“+”运算符以将 Money 类型的两个对象加在一起。当我尝试执行类似myMoney + 10myMoney 是 Money 类型的对象且 10 显然是整数的操作时,会出现错误消息。这是其余的相关代码:

class Money {
private:
    int dollars;
    int cents;
public:
    Money(double r);
    Money(int d) : dollars(d), cents(0) {}
    operator double();
}

Money operator+(Money a, Money b) {
    double r = double(a) + double(b);
    return Money(r);
}

Money::operator double() {
    return dollars+double(cents)/100;
}

Money::Money(double r) {
    ...
}
Run Code Online (Sandbox Code Playgroud)

如果我尝试并且使两个构造函数显式显示,该程序实际上可以工作Money(double(myMoney)+10),但我不确定我是否理解自动转换会发生什么。谁能解释这种行为?

c++ operator-overloading type-conversion explicit-constructor implicit-conversion

4
推荐指数
1
解决办法
2万
查看次数

C++ 结构体隐式转换

我需要声明大量简单的 POD 结构,它们的行为相同,但实际上是不同的类型,即不是 typedef。

无论如何,我只是想让它们尽可能简单。但是在测试时我看到编译器执行一些隐式转换,我想避免这种情况。

鉴于此代码:

  template<typename T>
  struct Struct {
    T data;

    operator T() const { return data; }
  };

  void fun(Struct<float> value)
  {
    cout << "Call with Struct :: " << value << endl;
  }

  void fun(int value)
  {
    cout << "Call with INT :: " << value << endl;
  }

int main(int, char**)
{
  fun(3);
  fun(4.1f);
  fun(Struct<float>{5.2});
  fun(Struct<double>{6.3});
  return 0;
}
Run Code Online (Sandbox Code Playgroud)

用 GCC 编译。

执行给了我:

Call with INT :: 3       // Ok
Call with INT :: 4 …
Run Code Online (Sandbox Code Playgroud)

c++ struct implicit-conversion c++11

4
推荐指数
1
解决办法
4591
查看次数

Signed Char 到 Unsigned Int 转换的标准 C++ 行为

我快速浏览了 C++03 标准,但仍然无法判断这种行为是否得到保证:

\n\n
signed char cNegOne=-1; //char is 8bits\nunsigned int a=cNegOne; //int is 32 bits in my Windows system\nprintf("0x%x\\n",a);\n
Run Code Online (Sandbox Code Playgroud)\n\n

结果是:

\n\n
0xffffffff\n
Run Code Online (Sandbox Code Playgroud)\n\n

VC++0xffffffff在 32 位 Windows 中提供。但我的假设是转换可能以两种方式发生:

\n\n

1) 8 位有符号 char -1 首先直接转换为 8 位无符号值,即二进制 11111111 或十进制 255,然后扩展为 32 位无符号 int,也给出 255 (0xff)。

\n\n

2) 8 位有符号 char -1 有符号扩展为 32 位有符号 int,给出 0xffffffff,然后重新解释为 32 位无符号 int。

\n\n

显然这里使用的是第二种方式。但为什么会这样呢?在标准中,我找不到任何谈论这个的内容。它是具体实施的吗?

\n\n

编辑:C++03 第 4 章的原文

\n\n

标准转换是为内置类型定义的隐式转换。第 4 条列举了完整的此类转换集。标准转换序列是按以下顺序进行的标准转换序列:

\n\n

\xe2\x80\x94 来自以下集合的零次或一次转换:左值到右值转换、数组到指针转换以及函数到指针转换。

\n\n

\xe2\x80\x94 …

c++ implicit-conversion c++03

4
推荐指数
1
解决办法
988
查看次数

std::basic_string 作为函数模板的参数不能从 const char* 推导出来

为什么std::basic_string作为函数模板的参数 put 会推演失败const char*,而直接构造却可以推演成功?

#include <string>
#include <iostream>
template<class Char/*, class Traits, class Allocator*/>   
                      //^doesn't matter whether the second and third template parameter is specified
void printString(std::basic_string<Char/*, Traits, Allocator*/> s)
{
    std::cout << s;
}
int main()
{
    printString("hello");    //nope
    std::basic_string s{ "hello" };//works
}
Run Code Online (Sandbox Code Playgroud)

我在这里找到了相关帖子,但答案没有解释背后的原因

c++ templates implicit-conversion template-argument-deduction

4
推荐指数
1
解决办法
408
查看次数

在初始化类类型时,C++ 可以执行多少次隐式转换来将一种用户定义类型转换为另一种类型?

#include <iostream>

struct Gadget
{
  Gadget() { puts("Gadget default"); }
  Gadget(char const *a) { puts("Gadget-const char* constructor"); }
  Gadget(Gadget const &other) { puts("Gadget copy"); }
  ~Gadget() { puts("\nGadget destruction"); }
};

struct Work
{
  Work() { puts("default"); }
  Work(const Gadget &a) { puts("Work-Gadget constructor"); }
  // Work(char const *a) { puts("Work-const char* constructor"); }
  Work(Work const &other) { puts("copy"); }
  ~Work() { puts("\nWork destruction"); }
};

int main()
{
  using namespace std;
  Work w = "std";  // error here;
} …
Run Code Online (Sandbox Code Playgroud)

c++ implicit-conversion

4
推荐指数
1
解决办法
288
查看次数

如何在函数参数中强制类型并避免隐式转换?

我有一个功能

template<typename T>
static inline bool Contains(T container, const typename T::value_type& value)
{
    return std::find(container.begin(), container.end(), value) != container.end();
}
Run Code Online (Sandbox Code Playgroud)

是否有选项禁止此函数的隐式转换?

这段代码应该编译失败:

std::vector<int> vec = {1, 2, 3};
Contains(vec, -5.2);
Run Code Online (Sandbox Code Playgroud)

在这篇文章中,如何避免对非构造函数进行隐式转换?它们完全消除了某些类型的使用,但事实并非如此。

谢谢。

c++ templates implicit-conversion

4
推荐指数
1
解决办法
86
查看次数

C++ 函数可以安全地比较不同类型的整数?

由于隐式转换以及std::numeric_limits<T>::max()and Friends 返回 type 的事实,编写一个在概念上“做正确的事情”的T函数似乎并不简单。也就是说,如果它们共享公共范围,则进行比较,如果不是,则确定是否小于,无论位数或符号性如何。有没有比这个简单的实现更简单的实现?:bool cmp(IntA a, IntB b)return a < b;ab

template <typename IntA, typename IntB>
[[nodiscard]] constexpr bool cmp(IntA a, IntB b) noexcept {
    static_assert(std::is_integral_v<IntA>);
    static_assert(sizeof(IntA) <= sizeof(long long int), "We assume we can fit everything into long long");
    static_assert(std::is_integral_v<IntB>);
    static_assert(sizeof(IntB) <= sizeof(long long int), "We assume we can fit everything into long long");
    if (a < 0) {
        if (b < 0) {
            return static_cast<signed long long int>(a) < …
Run Code Online (Sandbox Code Playgroud)

c++ integer-overflow implicit-conversion

4
推荐指数
1
解决办法
1054
查看次数

C++ 是否保证此 enum 与 int 构造函数重载解析?

考虑这个示例程序:

#include <iostream>

typedef enum { A, B, C } MyEnum;

struct S
{
    S(int) { std::cout << "int" << std::endl; }
    S(MyEnum) { std::cout << "MyEnum" << std::endl; }
};

S f()
{
    return A;
}

int main()
{
    S const s = f();
}
Run Code Online (Sandbox Code Playgroud)

使用 clang 和 gcc 编译,生成一个可执行文件,在运行时打印“MyEnum”。C++ 标准保证这种行为吗?

c++ overload-resolution implicit-conversion

4
推荐指数
1
解决办法
151
查看次数

在 C 中将数组作为参数传递

为什么这段代码有效?

#include <stdio.h>

void func(int v[]){
    v[0] = 1;
}

int main(){
    int v[5] = {0};
    func(v);
    for (int i = 0; i < 5; i++)
    {
        printf("%d ", v[i]);
    }
}
Run Code Online (Sandbox Code Playgroud)

我得到的输出是 '1 0 0 0 0' 但为什么呢?我没有传递指针,为什么该函数可以更改我的 main 中的数组?

c arrays pointers pass-by-reference implicit-conversion

4
推荐指数
1
解决办法
2116
查看次数