C++ 0x función objeto de función inferencia

Question

Soy un programador de Scala/Java que busca reintroducirse en C++ y aprender algunas de las características interesantes en C++ 0x. Quería comenzar diseñando mi propia biblioteca de colecciones ligeramente funcional, basada en las colecciones de Scala, para poder obtener una comprensión sólida de las plantillas. El problema al que me estoy enfrentando es que el compilador no parece ser capaz de inferir ningún tipo de información para los objetos de función con plantilla.

FC++ parece haber resuelto esto usando "Firmas". Estos parecen muy similares al tipo de nombre result_type, y pensé que obtendría esto usando la nueva sintaxis de la función. ¿Alguien puede sugerir una manera de hacer este tipo de cosas en C++ 0x, si es posible, o al menos explicar cómo FC++ fue capaz de lograr esto? He aquí un fragmento de código que estaba jugando con

#include <vector> 
#include <iostream> 
#include <algorithm> 
using namespace std; 

template<class T> 
class ArrayBuffer { 
private: 
    vector<T> array; 
public: 
    ArrayBuffer(); 
    ArrayBuffer(vector<T> a) : array(a) {} 

    template<typename Fn> 
    void foreach(Fn fn) { 
     for(unsigned int i = 0; i < array.size(); i++) fn(array[i]); 
    } 

    template<typename Fn> 
    auto map(Fn fn) -> ArrayBuffer<decltype(fn(T()))> { 
     vector<decltype(fn(T()))> result(array.size()); 
     for(int unsigned i = 0; i < array.size(); i++) result[i] = fn(array[i]); 
     return result; 
    } 
}; 

template<typename T> 
class Print { 
    public: 
    void operator()(T elem) { cout<<elem<<endl; } 
}; 

template<typename T> 
class Square{ 
public: 
    auto operator()(T elem) -> T { 
     return elem * elem; 
    } 
}; 

int main() { 
    vector<int> some_list = {5, 3, 1, 2, 4}; 
    ArrayBuffer<int> iterable(some_list); 
    ArrayBuffer<int> squared = iterable.map(Square<int>()); // works as expected 
    iterable.foreach(Print<int>()); // Prints 25 9 1 4 16 as expected 
    iterable.foreach(Print()); // Is there a way or syntax for the compiler to infer that the template must be an int? 
    ArrayBuffer<int> squared2 = iterable.map(Square()); // Same as above - compiler should be able to infer the template. 
} 

Answer 1

Puede hacer que el operator() una plantilla demasiado

class Print { 
    public: 
    template<typename T> 
    void operator()(T elem) { cout<<elem<<endl; } 
}; 

A continuación, puede pasar Print(). Para pasar argumentos al igual que en ArrayBuffer<decltype(fn(T()))> recomiendo el uso de declval, por lo que también podría trabajar con no predeterminado construible T

ArrayBuffer<decltype(fn(declval<T>()))> 

Answer 2

¿Hay una manera o de sintaxis para el compilador para inferir que la plantilla debe ser un int ?

El problema es la plantilla no necesita ser un int.
Esto es igualmente válido.

iterable.foreach(Print<float>()); 

Lo que realmente está preguntando es.
¿Puedo hacer que un funtor de plantilla tenga un valor predeterminado diferente según el contexto en el que se utiliza?

La respuesta es no. Supongo que teóricamente podríamos hacerlo por casos simples. Sin embargo, los casos de esquina rápidamente lo hacen inviable. El verdadero contexto de la función es la unidad de compilación completa, no solo la línea donde se crea una instancia.

Answer 3

Parece que está reinventando la biblioteca estándar de C++. No estoy hablando de tus contenedores.
C++ ya está bastante funcionalmente equipado.

Creo que te faltan algunos puntos clave sobre la biblioteca estándar de C++.

• Es Genérico primera y orientada a objetos segundos.
  Si se puede implementar un algoritmo de forma genérica, no se incluirá con la clase.
  ArrayBuffer::foreach == std::for_each
ArrayBuffer::map == std::transform
• Los algoritmos estándar funcionan en iteradores en lugar de contenedores completos. Esto a menudo se pierde por los nuevos programadores de C++ porque tanto Java como C# carecen del concepto. Los iteradores son más expresivos/flexibles que los contenedores solos. Iteradores son arguably el camino a seguir.Dicho esto, Ranges son una forma mucho más concisa de expresar iteradores (un rango son solo iteradores emparejados).

Aquí hay un ejemplo del uso funcional de C++. También es un buen ejemplo de por qué C# no usó iteradores. Aunque son muy poderosos, su verbosidad es intimidante para el público objetivo de C#. Java no usa iteradores ya que no están Orientado a objetos y los diseñadores de lengua fueron realmente anal sobre eso al principio.

struct Print 
{ 
    template<typename T> 
    void operator()(const T& t) 
    { std::cout << t << std::endl; } 
}; 

struct Squared 
{ 
    template<typename T> 
    T operator()(const T& t) 
    { return t*t; } 
}; 

int main() 
{ 
    std::vector<int> vi; 
    std::foreach(vi.begin(), vi.end(), Print()); 
    std::foreach(vi.begin(), vi.end(), [](int i){ std::cout<<i<<std::endl; }); 

    std::vector<int> vi_squared; 

    std::transform(vi.begin(), vi.end(), std::back_inserter(vi_squared), Squared()); 
    // or 
    vi_squared.resize(vi.size()); 
    std::transform(vi.begin(), vi.end(), vi_squared.begin(), Squared()); 
}