Question

是否可以将类型转换运算符定义为非成员全局功能？

#include <stdio.h>                                                                                                                                                      
#include <stdlib.h>                                                                                                                                                     

typedef int hash_t;                                                                                                                                                     

struct wrap {                                                                                                                                                           
    int v;                                                                                                                                                              
    operator hash_t () {                                                                                                                                                
        hash_t h = v+1;                                                                                                                                                 
        return h;                                                                                                                                                       
    }                                                                                                                                                                   
};                                                                                                                                                                      

int main(int argc, char **argv) {                                                                                                                                       
    int v = 1;                                                                                                                                                          
    hash_t h = (hash_t)wrap{v};                                                                                                                                         
    printf("%d\n", h);                                                                                                                                                  
    return 0;                                                                                                                                                           
}

而不是(hash_t)wrap{v}能够写(hash_t)v会有所帮助。不知道重载的语法是怎样的，但像operator hash_t (int v) { ... }这样的东西？或者类型转换运算符只能在类/结构的成员函数中重载吗？

我想定义一个字典template <typename key> CDict，并希望将key转换为int以将其用作哈希。但我不想根据键的类型调度哈希函数或使用虚函数，也可以使用int作为键的类型....相反，我想重载（hash_t）类型转换。这可能是全局类型转换超载（或者它们不会退出）吗？

Answer 1

看起来你真正想做的是根据类型调用不同的函数，运算符重载不是正确的方法。

相反，你可以创建一个自由函数来专门处理int，然后委托给非int情况下的成员函数

using hash_type = int;

// handle int
hash_type my_hash(int i) {
  return i;
}

// handle anything else
template <typename T>
hash_type my_hash(const T& t) {
  return t.hash(); // use whatever pattern you want here
}

template <typename Key, typename Value>
struct CDict {
  void insert(const Key& k, const Value& v) {
    auto hash = my_hash(k); // calls correct overload
  }
};

// a type with a hash member function
struct MyHashable {
  hash_type hash() const {
    return 0;
  }
};

int main() {
  CDict<int, double> c1;
  c1.insert(3, 5.0);

  CDict<MyHashable, char> c2;
  c2.insert(MyHashable{}, 'a');
}

请勿创建以_t，they are reserved

结尾的类型名称

具有非成员函数的Typecast运算符重载

1 个答案: