标签: implicit-conversion

d1 + 4工作原理,但4 + d1并不即使4可隐式转换为GMAN.为什么它们不相同？

struct GMan
{
    int a, b;

    GMan() : a(), b() {}
    GMan(int _a) : a(_a), b() {}
    GMan(int _a, int _b) : a(_a), b(_b) {}

    GMan operator +(const GMan& _b)
    {
         GMan d;
         d.a = this->a + _b.a;
         d.b = this->b + _b.b;
         return d;
    }
};

int main()
{
    GMan d1(1, 2), d(2);
    GMan d3;
    d3 = d1 + 4; 
    d3 = 4 + d1;
}

我想将隐式转换添加到由建模工具生成的Java类中.所以我想将它们添加到这些类的伴随对象中,以便编译器自动找到它们.但我无法将它们添加到单独的文件中,因为必须在同一文件中定义随播广告.我能做些什么吗？

当然,我可以在另一个对象中定义所有隐式转换,然后将其带入范围,但这需要额外的导入.还有其他方法吗？

可能重复:
隐式VS显式转换

"隐式转换"和"显式转换"之间有什么区别？Java和C++的区别是什么？

使用VC++ 2010,给出以下内容:

class Base { };
class Derived : public Base { };

template<class T> void foo(T& t);  // A
void foo(Base& base);              // B

Derived d;
foo(d);                            // calls A
foo(static_cast<Base&>(d));        // calls B

我想在上面调用"B".我可以用演员来实现这一点Base,但为什么这是必要的？

我希望为所有不是从Base(内置类型等)派生的类型调用模板函数,但我希望从派生类型调用非模板重载Base,而不需要客户端显式转换.我也尝试使重载成为模板的特化,但在这种情况下会发生相同的行为.得到我正在寻找的东西的惯用方法是什么？

我认为通过一个简单的例子来解释它更容易.(欢迎帮助改写标题;-)

我想实现一个squared方法,并使用implicit def,自动将其添加到任何支持*-operator的类.

使用Int非常容易:

class EnhancedInt(x: Int) { def squared = x * x }

implicit def IntToEnchancedInt(x: Int) = new EnhancedInt(x)

但是对于Any或AnyVal,我收到以下错误:

scala> class EnhanceAny(x: AnyVal) { def squared = x * x }
<console>:7: error: value * is not a member of AnyVal
       class EnhanceAny(x: AnyVal) { def squared = x * x }

我想知道如何将它应用于任何数字类,或者甚至更好地应用于任何支持*-operator的类.

我们有一个具有隐式字符串运算符的类型.它看起来像这样:

public class Foo
{
    readonly string _value;

    Foo(string value)
    {
        _value = value;
    }

    public static implicit operator string(Foo foo)
    {
        return foo._value;
    }

    public static implicit operator Foo(string fooAsText)
    {
        return new Foo(fooAsText);
    }

}

我们刚刚有一个实例传递给隐式运算符null的场景.显然,我们最终得到了一个NullReferenceException.

我认为这是很公平的,毕竟,什么是一个类型,它是空的字符串表示 - 很难说 - 这样的例外似乎是有效的,这是我们不应该拦截/禁止/手柄/忽略.我的理由是'有人给我一个空的,为什么我应该返回null.我不会在其他方法中这样做.我想,'我知道,我会在转换之前检查null',类似于:

string s = foo == null ? null : foo;

但这没有用,因为它现在在比较之前转换为字符串为null.当然,这种比较可行:

Foo f = null;
string s;
if (f != null)
{
    s = f;
}

......但那只是丑陋的.

我阅读了Essential …

这是代码:

#include <stdint.h>

unsigned char f(uint32_t RGBA)
{
  return (RGBA>>24) & 0xFF;
}

当使用-Wconversion它编译导致"警告:从'uint32_t {aka unsigned int}'转换为'unsigned char''可能会改变其值[-Wconversion]".如果我将移位值降低到23或更低,则警告消失.

我查看了C99标准,我不明白这里发生了什么.如果我删除了&运算符,那么总是会发出警告,这可能是好的,因为表达式(在整数提升之后)的结果大于unsigned char.我唯一的想法是,对于较小的班次省略警告只是因为gcc是聪明的并且看到结果仍然是8位,因为标准不会使这成为特殊情况.我在这儿吗？

为什么班次价值很重要？这是GCC的错误吗？Clang似乎没有为任何班次值产生警告.

我在64位Linux系统上使用GCC 5.3.1.

我正在使用转发构造函数创建一个瘦派生类.(请耐心等待,我必须使用缺少继承构造函数的GCC 4.7.2).

在第一次尝试时,我忘了添加explicit关键字并出错.有人可以解释为什么会发生这种特殊错误吗？我无法搞清楚事件的顺序.

#include <memory>

template<typename T>
struct shared_ptr : std::shared_ptr<T>
{
  template<typename...Args>
  /*explicit*/ shared_ptr(Args &&... args)
    : std::shared_ptr<T>(std::forward<Args>(args)...)
  {}
};

struct A {};

struct ConvertsToPtr
{
  shared_ptr<A> ptr = shared_ptr<A>(new A());
  operator shared_ptr<A> const &() const { return ptr; }
};

int main()
{
  shared_ptr<A> ptr;
  ptr = ConvertsToPtr(); // error here
  return 0;
}

错误:

test.cpp: In function ‘int main()’:
test.cpp:28:23: error: ambiguous overload for ‘operator=’ in ‘ptr = ConvertsToPtr()’
test.cpp:28:23: note: candidates are:
test.cpp:9:8: note: …

以下代码:

void f(const uint8_t* a) {}  // <- this is an external library function
enum E : uint8_t { X, Y, Z };

int main(void) {
  E e = X;
  f(&e);  // <- error here
}

产生以下错误:

/tmp/c.cc:10:3: error: no matching function for call to 'f'
  f(&e);
  ^
/tmp/c.cc:5:6: note: candidate function not viable: no known conversion from 'E *' to 'const uint8_t *' (aka 'const unsigned char *') for 1st argument
void f(const uint8_t* e) { }

这对我来说是令人惊讶的,因为我认为: …

在阅读了方法调用表达式，解引用运算符，方法查找和自动解引用之后，我认为我对该主题有了很好的理解。但是后来我遇到了一种情况，我希望自动重新引用会发生，而实际上却没有发生。

示例如下。

#[derive(Clone, Copy, Debug)]
struct Foo();

impl Into<&'static str> for Foo {
    fn into(self) -> &'static str {
        "<Foo as Into>::into"
    }
}

fn vec_into<F: Copy + Into<T>, T>(slice: &[F]) -> Vec<T> {
    slice.iter().map(|x| (*x).into()).collect()
}

fn main() {
    let array = [Foo(), Foo(), Foo()];
    let vec = vec_into::<_, &'static str>(&array);
    println!("{:?}", vec);
}

上面的代码有效，但是我认为不需要(*x).into()在函数中vec_into进行显式取消引用。我的理由是，因为x: &Foo，然后x.into()就试图找到接受类型的方法&Foo，&&Foo，&mut &Foo， …