en C++, quelle est la meilleure méthode pour alimenter le O/P d'une fonction à une autre fonction?

Question

Dans ces conditions,

1. Le o/p du premier programme est un grand choix de soit des entiers, doubles ou des chaînes.

2. La meilleure méthode est la plus rapide sur l'architecture x86.

   • o/p signifie sortie. Désolé d'être pas clair.

Answer 1

Si vous ne signifie sortie puis juste passer directement le tableau dans la fonction suivante avec un entier dire combien d'éléments il y a. Il passera l'adresse du premier élément (4 octets sur un système 32 bits ou 8 octets sur un système 64 bits), puis passera la taille dans 4 octets.

Si vous avez de la chance, le compilateur transmettra même ces paramètres via des registres.

Answer 2

Si vous parlez de deux programmes qui s'exécutent séparément, vous pouvez utiliser un objet pipe.
Dans les fenêtres que vous utilisez `CreateNamedPipe() »
http://msdn.microsoft.com/en-us/library/aa365150%28VS.85%29.aspx

Answer 3

Vous pouvez donner à la « autre » fonction à la première fonction de rappeler sur:

#include <algorithm> 
#include <iostream> 

template<typename It, typename It2, typename F1, typename F2> 
void combine(It from, It to, It2 out, F1 f1, F2 f2) { 
    for(int* p = from; p != to; ++p) { 
     *(out++) = f2(f1(*p)); 
    } 
} 

int increment(int i){ return ++i; } 

int twice(int i){ return i+i; } 

int main() { 
int ints[]={1,2,3,4}; 
int result[4]; 

combine(ints, ints+4, result, increment, twice); 
std::copy(result, result+4, std::ostream_iterator<int>(std::cout, "; ")); 

} 

En fait, ce mécanisme peut être étendu en versant les fonctions dans des objets de «première classe». La STL a des constructions pour y parvenir: si vous enveloppez vos fonctions libres dans un objet ptr_fun, vous pouvez construire un meilleur foncteur de combinaison. Dans l'implémentation STL de SGI, la fonction compose est disponible.

#include <functional> 


template<typename F1, typename F2> 
struct Combined : public std::unary_function 
         < typename F1::argument_type 
         , typename F2::result_type > { 

    typedef typename F2::result_type result_type; 
    typedef typename F1::argument_type argument_type; 

    Combined(F1 f1, F2 f2): f1_(f1), f2_(f2) {} 

    result_type operator()(argument_type arg) const { 
     return f2_(f1_(arg)); 
    } 

private: 
    F1 f1_; 
    F2 f2_; 
}; 

template<typename F1, typename F2> 
Combined<F1,F2> combined(F1 f1, F2 f2) { return Combined<F1,F2>(f1,f2); } 

Et puis utiliser cette fonctionnalité pour combiner des fonctions encore plus génériquement:

#include <iostream> 
#include <iterator> 
#include <algorithm> 

int increment(int i){ return ++i; } 
int twice(int i) { return 2*i; } 

int main() { 
    using namespace std; 
    int values[]={1,2,3,4}; 

    transform(values, values+4, ostream_iterator<int>(cout, "; "), 
       combined(ptr_fun(increment), ptr_fun(twice)) 
     ); 
    transform(values, values+4, ostream_iterator<int>(cout, "; "), 
       combined(ptr_fun(increment), 
         combined(ptr_fun(increment), ptr_fun(twice))) 
     ); 

}