C++ Template Meta pass_by_auto überprüfen.

[Sprachloser Dude (Gast)]

Wie kann ich herausfinden ob mein pass_by_auto richtig funktioniert. In 
der Typ-ID ist nichts zu erkennen, weder mit g++ noch dmc.

# include <iostream>
# include <typeinfo>
using std :: cout;
using std :: endl;
template <bool B, typename T, typename F>
struct when {
        typedef T type;
};
template <typename T, typename F>
struct when <false, T, F> {
        typedef F type;
};
template <typename T>
struct pass_by_auto {
        typedef typename when <
                sizeof (void*) <= sizeof (T)
                , T
                , T const&
                > :: type type;
};
template <typename T>
void f (typename pass_by_auto <T> :: type t) {
        cout << sizeof (t) << " Byte long = " << typeid (t) . name () << endl;
}
void g (int const& t) {
        cout << sizeof (t) << " Byte long = " << typeid (t) . name () << endl;
}
struct s {
        long i;
        double r;
};
int main (int argc, char** argv) {
        g (argc);
        f <int> (argc);
        f <char**> (argv);
        f <s> (s ());
        s o; f <s> (o);
}

% g++ -std=c++98 -pedantic -otest test.cpp
% ./test
4 Byte long = i
4 Byte long = i
8 Byte long = PPc
16 Byte long = 1s
16 Byte long = 1s

>dmc test.cpp
>.\test.exe
4 Byte long = int
4 Byte long = int
4 Byte long = char **
16 Byte long = s
16 Byte long = s

[Programmierer (Gast)]

Versuch doch einfach innerhalb der Funktion einen Wert in den Parameter 
zu schreiben. Wenn's nicht klappt, wars die konstante Referenz.
Warum benutzt du nicht std::conditional_t ?
So ginge es doch praktischer:

template <typename T>
using pass_by_auto = std::conditional_t<
                sizeof (void*) <= sizeof (T)
                , T
                , T const&
                >;

template <typename T>
void f (pass_by_auto <T> t) {
}

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Sprachloser Dude schrieb:
> Wie kann ich herausfinden ob mein pass_by_auto richtig funktioniert.

Du könntest in ein paar Test-Aufrufen ein static_assert auf den Test, 
auf den erwarteten Typen machen:

void f( typename pass_by_auto<std::string>::type )
{
    static_assert(
        std::is_same<
            typename pass_by_auto<std::string>::type, 
            const std::string& >::value);
}

[Sprachloser Dude (Gast)]

Programmierer schrieb:
> Versuch doch einfach innerhalb der Funktion einen Wert in den Parameter
> zu schreiben. [...]

Torsten R. schrieb:
> [...] Du könntest in ein paar Test-Aufrufen ein static_assert auf den Test,
> auf den erwarteten Typen machen: [...]

Ok, habs mal so gemacht.

Programmierer schrieb:
> [...] Warum benutzt du nicht std::conditional_t ? [...]

Long story short, weil ich vor Jahren SICP [1] angelesen hab und 
kürzlich Category Theory for Programmers [2]. Und da ja 
C++‑Template‑Metaprogrogrammirung rein funktionale Programmierung ist 
versuch da grad verständnismäßig die Brücke von Haskell und auch Scheme 
zu den neueren Features in C++ zu schlagen.

[1] 
https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html
[2] 
https://github.com/hmemcpy/milewski-ctfp-pdf/releases/download/v1.3.0/category-theory-for-programmers.pdf