标签: implicit-conversion

字符串隐式转换列表,如+ =

请考虑以下代码段.+ =不是java.lang.String的成员,所以我猜有某种隐式转换正在进行中.如何查找作用于String的此类预定义隐式转换的列表?

scala> var x = "asdf"
x: java.lang.String = asdf

scala> x += x

scala> x
res2: java.lang.String = asdfasdf
Run Code Online (Sandbox Code Playgroud)

scala implicit-conversion

3
推荐指数
2
解决办法
549
查看次数

禁止C++编译器自动提供的功能

Scott Meyers在他的书"Effective C++"中说,

要禁止编译器自动提供的功能,请将相应的成员函数声明为private并且不执行任何实现.然后,如果有人无意中调用了一个,则会在链接时出现错误.

我试图编写一个示例程序来实现Scott试图解释的内容.即使声明了成员函数public并且没有实现,我也可以实现相同的目标.当我试图从另一个对象初始化一个对象时,我的情况也发生了链接错误.所以我不明白为什么斯科特强调要宣布成员函数的需要private?

我的示例程序如下:

#include <iostream>

using namespace std;

class Unique
{
   private:
      int num;

   public:
      Unique(int x)
      {
         num  = x;
      }
      Unique(const Unique &obj);

      Unique& operator =(const Unique &obj);

      void disp(void)
      {
         cout << "num = " << num << "\n";
      }
};

int main()
{
   Unique ob1(3);
   Unique ob2(ob1);

   ob1.disp();
   ob2.disp();

   return 0;
}
Run Code Online (Sandbox Code Playgroud)

我收到以下链接错误:

/tmp/ccXfqSqE.o(.text+0x135):在函数main': : undefined reference toUnique :: Unique(Unique const&)'collect2:ld返回1退出状态

c++ constructor operator-overloading access-specifier implicit-conversion

3
推荐指数
1
解决办法
187
查看次数

从operator ==隐式调用构造函数

我有以下代码:

class Employee {
friend string FindAddr( list<Employee> lst,string name );
public:
Employee(const string& s){ cout << "Employee CTOR" << endl;}
bool operator==( Employee& e) {
    return e.name == name;
}
private:
string name;
string addr;
};


string FindAddr( list<Employee> lst, string name ) { 
string result = "";
for( list<Employee>::iterator itr = lst.begin(); itr != lst.end(); itr++ ) { 
    if ( *itr == name ) { // Problematic code
        return (*itr).addr;
    }
}
return result;
}
Run Code Online (Sandbox Code Playgroud)

据我了解,有问题的行if ( …

c++ operators implicit implicit-conversion

3
推荐指数
1
解决办法
231
查看次数

如何使用隐式方式查找转换为具有方法名称的类型?

在另一个答案中,他们给出了以下代码示例:

scala> implicitly[Int => { def min(i: Int): Any }]
res22: (Int) => AnyRef{def min(i: Int): Any} = <function1>
Run Code Online (Sandbox Code Playgroud)

这在我的scala控制台(2.10.0-RC2)中不起作用.

scala> implicitly[Int => { def min(i: Int): Any }]
<console>:8: error: No implicit view available from Int => AnyRef{def min(i: Int): Any}.
          implicitly[Int => { def min(i: Int): Any }]
                    ^
scala> 12 min 11
res15: Int = 11
Run Code Online (Sandbox Code Playgroud)

这样做的新方法是什么?那个语法究竟意味着什么呢?我不熟悉它 - 特别是{ def min(i: Int): Any }用作类型表达式的部分.这是否定义了某种匿名类型?

我想这样做是因为当我在代码中看到它并且不知道它从哪里导入时我想跟踪隐式转换.例如,前几天我看到一些代码正在调用formata java.util.Date,而这些代码没有format.我不知道转换中的哪个导入.

scala implicit-conversion

3
推荐指数
1
解决办法
159
查看次数

C++中的隐式转换

在C++中,我试图使用条件运算符进行隐式转换.考虑这个例子:

class MyFloat
{ 
    public:                                                                    
        MyFloat(float val){m_val = val;}
        operator float(){return m_val;}
    protected:
        float m_val;
};

int main(int argc, char **argv)
{
    MyFloat a = 0.5f;
    MyFloat b = 1.0f;                            
    float x = true ? a-0.5f : b;
    return 0;
}
Run Code Online (Sandbox Code Playgroud)

它会导致编译器错误:

error: operands to ?: have different types ‘MyFloat’ and ‘float’
Run Code Online (Sandbox Code Playgroud)

我希望条件运算符隐式转换b为a-0.5float 类型.但这不会发生.我如何实现这种隐式演员?

理想情况下,我想避免静态强制转换或访问方法float MyFloat::getValue().

c++ casting conditional-operator implicit-conversion

3
推荐指数
1
解决办法
1881
查看次数

为什么+符号是javascript中的例外?

我这样做了

> 5 + 2 // 7, this is correct 

> 5 - 2 // 3 , obviously 

> 5 - "2" // 3 , ohh, that's awesome 

> 5 % "2" // 1 , :)

> 5 / "2" // 2.5,looks like 2 is automatically converted to integer.Perfect!

> 5 + "2" // "52" Really? 
Run Code Online (Sandbox Code Playgroud)

确定性,额外的东西正在加号.那是什么,为什么?

javascript dynamic-typing implicit-conversion

3
推荐指数
1
解决办法
113
查看次数

强制缩小转换警告

请考虑以下代码,说明一些缩小的转换:

template <class T>
class wrapper 
{   
    template <class> friend class wrapper;
    public:
        constexpr wrapper(T value)
        : _data(value)
        {}
        template <class U>
        constexpr wrapper(wrapper<U> other)
        : _data(other._data) 
        {}
        wrapper& operator=(T value)
        {_data = value; return *this;}
        template <class U>
        wrapper& operator=(wrapper<U> other)
        {_data = other._data; return *this;}
    private:
        T _data;
};

int main(int argc, char* argv[]) 
{
    wrapper<unsigned char> wrapper1 = 5U;
    wrapper<unsigned char> wrapper2{5U};
    wrapper<unsigned char> wrapper3(5U);
    wrapper<unsigned int> wrapper4 = 5U;
    wrapper<unsigned int> wrapper5{5U};
    wrapper<unsigned int> wrapper6(5U);
    wrapper<unsigned …
Run Code Online (Sandbox Code Playgroud)

c++ compiler-warnings implicit-conversion narrowing c++14

3
推荐指数
1
解决办法
531
查看次数

传递const int *和int *时,将调用不同版本的重载函数(const int * const&/ &amp;&amp;)

我在代码中遇到了一个错误,该错误正在调用错误的重载函数。

问题归结为:

void func(const int* const& ptr){
    std::cout << "LValue reference\n";
}
void func(const int* const&& ptr){
    std::cout << "RValue reference\n";
}

int main(){
    const int* ptr;

    func(ptr);

    return 0;
}
Run Code Online (Sandbox Code Playgroud)

上面的代码按预期工作,它打印LValue reference。但是,当我改变const int* ptr到int* ptr,该程序打印RValue reference。这对我来说很奇怪,因为我通过了一个确认的LValue。这使我相信正在发生某种隐式转换,从而将其转换为RValue。我确实使用godbolt编译器资源管理器进行了研究,乍看之下它会证实我的怀疑,但是我对汇编一无所知,因此无法确定。

所以问题是:这里发生了什么?

c++ pass-by-reference rvalue lvalue implicit-conversion

3
推荐指数
1
解决办法
56
查看次数

为什么该类型为double而不是float?

问题:在一项家庭作业问题中(必须用笔在纸上完成,因此无需编码),我必须确定用C ++执行的加法的类型和值。

1 + 0.5
Run Code Online (Sandbox Code Playgroud)

我已经回答的是:

  • 输入float(因为我以为是integer + float = float)
  • 值1.5(据我所知,当添加两个不同的数据类型时,相加的结果将转换为不会丢失任何信息的数据类型。)

解决方案说:

  • 类型:双
  • 价值:1.5

我的问题:为什么0.5是两倍而不是浮点数?如何区分浮点数和双精度数?我的意思是,0.5在我看来就像是浮点数和两倍。

c++ floating-point language-lawyer implicit-conversion

3
推荐指数
2
解决办法
160
查看次数

uint64_t的安全低32位屏蔽

假设以下代码:

uint64_t g_global_var;

....
....

void foo(void)
{
    uint64_t local_32bit_low = g_global_var & 0xFFFFFFFF;
    ....
}
Run Code Online (Sandbox Code Playgroud)

使用当前的工具链,此代码可以按预期工作,local_32bit_low实际上包含的低32位g_global_var。

我想知道标准C是否保证该代码将始终按预期工作?我担心的是,编译器可能会将0xFFFFFFFF视为-1的整数,并且提升为uint64_t0xFFFFFFFFFFFFFFFF时。

聚苯乙烯

我知道,为了安全起见,在这种情况下最好使用0xFFFFFFFFULL。关键是我在旧版代码中看到了它,我想知道是否值得修复。

c 64-bit bit-manipulation bitmask implicit-conversion

3
推荐指数
1
解决办法
116
查看次数