шаблоны оператора в C++

Question

Если я хочу создать шаблон функции, где параметр шаблона не используется в списке аргументов, я могу это сделать таким образом:

template<T> 
T myFunction() 
{ 
//return some T 
} 

Но вызов должен указать «T 'использовать, поскольку компилятор не знает, как это работает.

myFunction<int>(); 

Но, предположим, я хотел сделать что-то подобное, но для оператора []. шаблон

T SomeObject::operator [ unsigned int ] 
{ 
    //Return some T 
} 

Есть ли способ вызова этого оператора? Это не появляется в силе:

SomeObject a; 
a<int>[3]; 

Answer 1

Это должно работать:

class C 
{ 
public: 
    template <class T> 
    T operator[](int n) 
    { 
     return T(); 
    } 
}; 

void foo() 
{ 
    C c; 

    int x = c.operator[]<int>(0); 
} 

Но это не имеет никакого реального значения, потому что вы всегда должны были бы указать тип, и поэтому он выглядит как вызов очень некрасивой функции - точка перегрузки оператора является чтобы выглядеть как вызов оператора.

Answer 2

Как с любым оператором, имя функции является operator@, так:

a.operator[]<int>(3); 

Answer 3

Вы можете использовать a.operator [] <INT> (1); Но зачем вам это нужно?

Answer 4

Это не может быть оптимальным решением, но вы можете напрямую позвонить оператору, как например:

a.operator[](3);

Я попробовал это в г ++ со следующим испытанием:

class MyClass { 
public: 
    template<class T> 
    T operator[](unsigned int) { 
     // do something 
     return T(); 
    } 
}; 

int main(int argc, char* argv[]) { 
    MyClass test; 
    test.operator[]<int>(0); 
    //test<int>[0]; // doesn't compile, as you mentioned 
    return 0; 
}

Answer 5

Если вам нужно define operator [], то, вероятно, определите шаблон на уровне класса. Что-то вроде этого:

template<class T> 
class C 
{ 
public: 
    T operator[](int n) 
    { 
     return T(); 
    } 
}; 

int main() 
{ 
    C<int> c; 

    int x = c[0]; 

    return 0; 
} 

Answer 6

У меня есть трудное время придумать пример, где это было бы необходимо (не мог просто перегрузки оператор вместо этого?), Но вот мои мысли так или иначе:

Поскольку вы не можете использовать синтаксис оператора infix с templatized операторами, вы можете захотеть создать экземпляр шаблона до, который вы вызываете оператором. Прокси-сервер может быть способом сделать это.

class some_class { 
private: 
    template<class T> class proxy { 
    some_class* that_; 
    public: 
    proxy(some_class* that) : that_(that) {} 
    T& operator[](std::size_type idx) {return that->get<T>(idx);} 
    }; 

    template<class T> class const_proxy { 
    some_class* that_; 
    public: 
    proxy(const some_class* that) : that_(that) {} 
    const T& operator[](std::size_type idx) const {return that->get<T>(idx);} 
    }; 

    template< typename T >  proxy<T> get_array()  {return proxy<T>(this);} 
    template< typename T > const_proxy<T> get_array() const {return proxy<T>(this);} 

    template< typename T >  T& get(std::size_t idx)  {/* whatever */} 
    template< typename T > const T& get(std::size_t idx) const {/* whatever */} 
}; 

// This is a lousy use case. 
// Did I already say I have a hard time imagining how to use this? 
template< typename T > 
void f(some_class& some_object, sid::size_t idx) 
{ 
    T& = some_object.get_array<T>()[idx]; 
} 

Answer 7

Boost.Program_options использует этот аккуратный синтаксис:

int& i = a["option"].as<int>(); 

что достигается с чем-то вроде этого:

class variable_value 
{ 
public: 
    variable_value(const boost::any& value) : m_value(value) {} 

    template<class T> 
    const T& as() const { 
     return boost::any_cast<const T&>(m_value); 
    } 

    template<class T> 
    T& as() { 
     return boost::any_cast<T&>(m_value); 
    } 

private: 
    boost::any m_value; 
}; 

class variables_map 
{ 
public: 
    const variable_value& operator[](const std::string& name) const 
    { 
     return m_variables[name]; 
    } 

    variable_value& operator[](const std::string& name) 
    { 
     return m_variables[name]; 
    } 

private: 
    std::map<std::string, variable_value> m_variables; 
}; 

Вы могли бы приспособить эту идею, чтобы удовлетворить свои собственные потребности.