Come applicare la funzione a tutti gli elementi dell'array (in classe template C++)

Question

Ho una classe template che memorizza una serie di numeri e voglio applicare le funzioni esistenti (scalari) a ogni elemento. Per esempio, se assumiamo che la mia classe sia std :: vector, allora voglio essere in grado di chiamare (per esempio) la funzione std :: cos su tutti gli elementi.

Forse una chiamata sarebbe simile a questa:

std::vector<float> A(3, 0.1f); 
std::vector<float> B = vector_function(std::cos, A); 

N.B. Devo anche gestire i tipi std :: complex <> (per i quali viene chiamata la funzione std :: cos del complesso appropriato).

ho trovato this answer che suggerisce di prendere il tipo di funzione come parametro di template:

template<typename T, typename F> 
std::vector<T> vector_function(F func, std::vector<T> x) 

Tuttavia, non ho potuto ottenere questo lavoro a tutti (forse perché funzioni come std :: peccato e std: : cos sono entrambi modelli e sovraccarico?).

Ho anche provato a utilizzare std::transform, ma questo è diventato rapidamente molto brutto. Per i tipi non complessi, sono riuscito a farlo funzionare con un typedef:

std::vector<float> A(2, -1.23f); 
typedef float (*func_ptr)(float); 
std::transform(A.begin(), A.end(), A.begin(), (func_ptr) std::abs); 

Tuttavia, tentando lo stesso trucco con <> tipi std :: complesso causato un crash di run-time.

C'è un modo carino per farlo funzionare? Sono stato bloccato su questo per anni.

Answer 1

Dovresti dare un'occhiata a questo post di Richel Bilderbeek (Math code snippet to make all elements in a container positive) che ti mostra perché abs non funzionerà in una trasformazione del genere. Il motivo per cui non funziona è dovuto alla struttura della funzione abs (vedere http://www.cplusplus.com/reference/cstdlib/abs/). Vedrete che abs non è un modello a se stesso diverso da altre funzioni (principalmente funzioni binarie) trovate nella libreria functional. Una soluzione disponibile sul sito web di Richel per mostrarti come applicare abs per dire, un vettore di numeri interi.

Ora se si desidera applicare abs a un contenitore utilizzando la trasformazione, è necessario sapere che la funzione di trasformazione ha ricevuto un oggetto complesso e non saprà come applicare abs ad esso. Il modo più semplice per risolverlo è scrivere semplicemente le proprie funzioni unario basate su modelli.

Ho un esempio qui sotto dove applico abs alle parti reali e immaginarie dell'oggetto complesso.

#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <complex> 
#include <functional> 

template <typename T> 
std::complex<T> abs(const std::complex<T> &in) { 
    return std::complex<T>(std::abs(in.real()), std::abs(in.imag())); 
}; 

int main() { 
    std::vector<std::complex<int>> v; 
    std::complex<int> c(10,-6); 
    v.push_back(c); 
    std::complex<int> d(-5, 5); 
    v.push_back(d); 

    std::transform(v.begin(), v.end(), v.begin(), abs<int>); 

    //Print out result 
    for (auto it = v.begin(); it != v.end(); ++it) 
    std::cout << *it << std::endl; 

    return 0; 
} 

Come lei ha detto, si voleva fare applicare l'abs dalla libreria complex. Per evitare il comportamento non specificato (vedere this) si utilizzerà il nome di tipo double per gli oggetti complessi.

Answer 2

penso ancora che si dovrebbe usare std::transform:

template <class OutputIter, class UnaryFunction> 
void apply_pointwise(OutputIter first, OutputIter last, UnaryFunction f) 
{ 
    std::transform(first, last, first, f); 
} 

Questa funzione non solo per std::vector tipi, ma anzi ogni contenitore che ha una funzione begin() e end() membro, e funziona anche per il C- array di stile con l'aiuto delle funzioni gratuite std::begin e std::end. La funzione unaria può essere qualsiasi funzione libera, un oggetto functor, un'espressione lambda o anche funzioni membro di una classe.

Per quanto riguarda il problema con std::sin, questa funzione gratuita è basata su modelli e quindi il compilatore non può sapere quale istanza del modello è necessaria.

Se si ha accesso a C++ 11, quindi è sufficiente utilizzare un'espressione lambda:

std::vector<float> v; 
// ... 
apply_pointwise(v.begin(), v.end(), [](const float f) 
{ 
    return std::sin(f); 
}); 

In questo modo, il compilatore sa che dovrebbe sostituire T=float come parametro del modello.

Se è possibile utilizzare le funzioni C, è anche possibile utilizzare la funzione sinf, che non è basato su modelli e prende un float come parametro:

apply_pointwise(v.begin(), v.end(), sinf);