13. hét: Paraméterlisták és -továbbítás, ...

A megoldás két helyen is C++17 elemet használ, folding expression-t: (... && B) és (1 * ... * sizes). De ezeket nagyon könnyű lenne megírni rekurzívan is.

#include <iostream>
#include <iomanip>
#include <type_traits>
#include <vector>
#include <array>

/* And<true, false, true, ...>::value */
template <bool ... B>
class And : public std::bool_constant<(... && B)> {};

/* AllInt<size_t, int, long>::value */
template <typename... TS>
class AllInt : public And<std::is_convertible<TS, size_t>::value...> {};

template <typename T, size_t DIM>
class Array {
    private:
        /* ez tárolja, hogy melyik irányban mekkora méretű */
        std::array<size_t, DIM> sizes;
        /* ez a tényleges adattömb, leképezve 1 dimenzióra */
        std::vector<T> data;

    public:
        template <typename... ARGS,
                  typename = typename std::enable_if<AllInt<ARGS...>::value>::type,
                  typename = typename std::enable_if<sizeof...(ARGS)==DIM>::type>
        Array(ARGS ... sizes)
            : sizes{size_t(sizes)...}
            , data((1 * ... * sizes))
        {
        }

        template <typename... ARGS,
                  typename = typename std::enable_if<AllInt<ARGS...>::value>::type,
                  typename = typename std::enable_if<sizeof...(ARGS)==DIM>::type>
        T & operator() (ARGS ... indices_)
        {
            std::array<size_t, DIM> indices = { size_t(indices_) ... };
            /* ijesztően néz ki, hogy minden indexelésnél ezt csináljuk, de
             * megijedés helyett érdemes megnézni a lefordított, optimalizált kódot! */
            size_t idx = indices[0];
            for (size_t i = 1; i < DIM; ++i)
                idx = idx*sizes[i-1] + indices[i];
            return data[idx];
        }
};

int main() {
    Array<double, 2> a(3, 4);
    
    for (int i = 0; i < 3; ++i)
        for (int j = 0; j < 4; ++j)
            a(i, j) = (i+1)*(j+1);
            
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j)
            std::cout << std::setw(10) << a(i, j);
        std::cout << std::endl;
    }
}

/* Ez itt a referencia objektum */
template <typename FUNCTOR>
class RefProxy {
  private:
    /* Amely a függvényobjektumot referencia szerint tartalmazza */
    FUNCTOR &f;
  public:
    /* A konstruktora eltárolja a referenciát */
    RefProxy(FUNCTOR & f) : f(f) {}

    /* És ha bármilyen paraméterekkel meghívják */
    template <typename... ARGS>
    auto operator() (ARGS && ... args)
      /* Akkor egy ugyanolyan típusú értékkel tér vissza, mint
       * amilyennel a függvényobjektum visszatérne */
      -> decltype(f(std::forward<ARGS...>(args...)))
    {
        /* És továbbpasszolja a paramétereket
         * a hivatkozott függvényobjektumnak */
        return f(std::forward<ARGS...>(args...));
    }
};


/* Ez a függvény hozza létre a RefProxy-t. Tulajdonképpen csak
 * azért van, hogy kitalálja a FUNCTOR típusát. */
template <typename FUNCTOR>
auto make_refproxy(FUNCTOR & f) -> RefProxy<FUNCTOR> {
    return RefProxy<FUNCTOR>{f};
}

Ehhez az osztályodnak egy olyan operator= kell, amelyik tetszőleges objektumot (függvénypointert, lambdát, ...) át tud venni, és le tud másolni. Ezért a lemásolt objektumot be kell majd csomagolnod egy osztályba, aminek típusa a lemásolt objektumtól függ. Hogy erre lehessen hivatkozni, a különféle elképzelhető csomagoló osztályokhoz szükség van egy közös ősosztályra.

Figyelj arra, hogyan adod át a becsomagolt függvénynek a paramétereket! Meg arra is, hogy egy std::function lemásolásakor lemásolódik a bele csomagolt funktort is. Ez azért fontos, mert a funktornak belső állapota lehet. Az std::function ilyen jellegű viselkedését is tudnia kell az osztálynak.

Egy std::unique_ptr kell. A function objektum másoló konstruktorát ilyenkor is meg kell írni (mert klónozni kell benne), viszont a mozgató konstruktor és a destruktor lehet default. Ugyanez a helyzet az értékadó operátorokkal, amelyek megírhatók egyben, move and swap segítségével.

Becsomagolja a paraméterként adott függvényt egy másik függvénybe, amely ellenőrzi azt, hogy hívták-e már pontosan azokkal a paraméterekkel, mint amiket most lát. Ha igen, akkor nem értékeli ki újra a függvényt, hanem csak visszatér az eltárolt értékkel. Ha nem, akkor meghívja és eltárolja a visszaadott értékét, hogy legközelebb már ne kelljen.

double sin_with_print(double x) {
    std::cout << "sin_with_print(x) called\n";
    return sin(x);
}

int main() {
    auto msin = memoized_func(sin_with_print);
    std::cout << msin(1.0) << std::endl;
    std::cout << msin(1.0) << std::endl;
    std::cout << msin(2.0) << std::endl;
    std::cout << msin(2.0) << std::endl;
    std::cout << msin(1.0) << std::endl;
    std::cout << msin(1.0) << std::endl;
}

sin_with_print(x) called
0.841471                sin(1.0) először
0.841471
sin_with_print(x) called
0.909297                sin(2.0) először
0.909297
0.841471
0.841471

Akkor érdemes használni, ha a függvény kiértékelése lassú – sokkal lassabb, mint amennyi ideig a map-ben keresés tart. Nem szabad használni, ha a meghívott függvénynek mellékhatása van, mert a mellékhatás csak egyszer fog megtörténni (adott paraméterek mellett mindig az első híváskor).

Klasszikus megoldás:

#include <iostream>
#include <string>
#include <sstream>

void set_vars(std::istringstream &) {
}

template <typename HEAD, typename... TAIL>
void set_vars(std::istringstream & is, HEAD & arg, TAIL &... tail) {
    is >> arg;
    set_vars(is, tail...);
}

template <typename... ARGS>
void unpack(std::string const & words, ARGS & ... args) {
    std::istringstream is(words);
    set_vars(is, args...);
}


int main() {
    int a;
    double b;

    unpack("3 4.5", a, b);
    std::cout << a << " " << b;
}

Esetleg C++17-ben:

template <typename ... ARGS>
void unpack(std::string const & str, ARGS & ... args) {
    std::istringstream is(str);
    (is >> ... >> args);
}

Vagy C++11-ben, a swallow{}-os trükkel:

template <typename ... ARGS>
void unpack(std::string const & str, ARGS & ... args) {
    std::istringstream is(str);
    
    using swallow = int[];
    swallow{0, (void(is >> args), 0)...};
}

#include <sstream>
#include <string>
#include <iostream>
#include <tuple>

template <typename ... TYPES>
class List {
    private:
        std::tuple<TYPES & ...> refs;
        
        template <int N>
        void unpack(std::istringstream & is) {
            if constexpr (N != sizeof...(TYPES)) {
                is >> std::get<N>(refs);
                unpack<N+1>(is);
            }
        }
    
    
    public:
        List(TYPES & ... args) : refs(args...) {}
        
        void operator=(std::string s) {
            std::istringstream is(s);
            unpack<0>(is);
        }
};

template <typename ... TYPES>
auto list(TYPES & ... args) {
    return List<TYPES & ...>(args...);
}

std::string explode(std::string s) {
    return s;
}

int main() {
    int a;
    double b;
    list(a, b) = explode("3 4.5");
}

int greatest(int arr[], int size, int max) {
    if (size == 0)
        return max;
    else
        return greatest(arr+1, size-1, arr[0] > max ? arr[0] : max);
}
int greatest(int arr[], int size) {
    return greatest(arr+1, size-1, arr[0]);
}

#include <iostream>

template <int max, int... numbers>
struct GreatestHelper;

template <int max, int head, int... tail>  // 1
struct GreatestHelper<max, head, tail...> {
    static constexpr int value = GreatestHelper<(head > max) ? head : max, tail...>::value;
};

template <int max>
struct GreatestHelper<max> {               // 2
    static constexpr int value = max;
};

template <int head, int... tail>
struct Greatest {
    static constexpr int value = GreatestHelper<head, tail...>::value;
};

int main() {
    std::cout << Greatest<4, 87, 2, 65, 89, 1>::value << std::endl;
}

A fenti kódban a Greatest osztály indítja el a rekurziót, a GreatestHelper osztály példányosításával. A GreatestHelper osztály első paramétere, a max nevű, a rekurzióban használt gyűjtőparaméter; a megvizsgált számok közül ez tárolja a legnagyobbat. (A rekurzió indulásakor ez a sorozat első elemét kapja.)

A segédosztálynak két specializációja van. Az 1-gyessel jelöltet használja a fordító akkor, ha legalább két sablonparaméter van (a gyűjtőparaméter és a vizsgálandó számok), a 2-es változatot pedig akkor, ha már nincs vizsgálandó szám. Az eredeti osztálydeklaráció célja csak annyi, hogy megadja a fordító számára a sablonparamétereket, utána már lehet specializálni az osztályt.

Természetesen működne az a módszer is, ahol az általános eset a legalább két paraméterű, az egyetlen specializáció pedig a pontosan két paraméterű. De így tartalmaz a megoldás egy kis kódduplikációt, tehát a fenti megoldás szebb.

template <int max, int head, int... tail>
struct GreatestHelper {
    static constexpr int value = GreatestHelper<(head > max) ? head : max, tail...>::value;
};
template <int max, int head>
struct GreatestHelper<max, head> {
    static constexpr int value = head > max ? head : max;
};

/* gens<4> -> N = 4, S = üres */
class gens<4> : gens<3, 3> { };

/* gens<3, 3> -> N = 3, S = 3 */
class gens<3, 3> : gens<2, 2, 3> { };

/* gens<2, 2, 3> -> N = 2, S = 2, 3 */
class gens<2, 2, 3> : gens<1, 1, 2, 3> { };

/* gens<1, 1, 2, 3> -> N = 1, S = 1, 2, 3 */
class gens<1, 1, 2, 3> : gens<0, 0, 1, 2, 3> { };

/* gens<0, 0, 1, 2, 3> -> specializáció! nincs N, S = 0, 1, 2, 3 */
class gens<0, 1, 2, 3> {
    using type = seq<0, 1, 2, 3>;
};

És ezt a type belső típust megörökik az előző, meg az azelőtti stb. osztályok, tehát végül gens<4>::type = seq<0, 1, 2, 3>. A gens<N> osztály előállítja seq osztály sablonparamétereként a 0 ... N-1 természetes számokat.

template <int... S>
class SumLen;

template <int X, int... XS>
class SumLen<X, XS...> {
  private:
      using Rest = SumLen<XS...>;

  public:
    static constexpr int value  = X + Rest::value;
    static constexpr int length = 1 + Rest::length;
};

template <>
class SumLen<> {
  public:
    static constexpr int value  = 0;
    static constexpr int length = 0;
};

A megoldásban a SumLen osztálynak egy sablonparamétere van csak, egy típus. Egy Szamok>X, XS...> paraméterű részleges specializáció lehet az, amelyik az egyetlen egy sablonparaméterből, a típusból „ki tudja csomagolni” ezeket az egész számokat.

template <int... S>
class Szamok;

template <typename SZAMOK>
class SumLen;

template <int X, int... XS>
class SumLen<Szamok<X, XS...>> {
  private:
    using Rest = SumLen<Szamok<XS...>>;

  public:
    static constexpr int value  = X + Rest::value;
    static constexpr int length = 1 + Rest::length;
};

template <>
class SumLen<Szamok<>> {
  public:
    static constexpr int value  = 0;
    static constexpr int length = 0;
};

Lásd a következő két feladatnál.

C++17-ben ez nagyon könnyű folding expression segítségével. A típusokat tartalmazó osztály nélkül:

template <typename T, typename ... LIST>
struct IsTypeInList {
    static constexpr bool value = (std::is_same<T, LIST>::value || ...);
};

Klasszikus megoldás rekurzióval:

template <typename T, typename ... LIST>
struct IsTypeInList;

template <typename T>
struct IsTypeInList<T> {    /* üres listára */
    static constexpr bool value = false;
};

template <typename T, typename HEAD, typename ... TAIL>
struct IsTypeInList<T, HEAD, TAIL...> { /* egy elemű vagy annál hosszabb listára */
    /* az első az, vagy a többi közt kell legyen */
    static constexpr bool value =
        std::is_same<T, HEAD>::value || IsTypeInList<T, TAIL...>::value;
};

Lásd a következő két feladatnál.

#include <iostream>
#include <type_traits>
#include <functional>

/* NthType - N-edik típus kiválasztása egy listából */
namespace {
    template <unsigned N, typename... TYPES>
    class NthTypeImpl;

    template <typename HEAD, typename ... TAIL>
    class NthTypeImpl<0, HEAD, TAIL...> {
        public:
            using type = HEAD;
    };

    template <unsigned N, typename HEAD, typename ... TAIL>
    class NthTypeImpl<N, HEAD, TAIL...> : public NthTypeImpl<N - 1, TAIL...> {};
}

template <unsigned N, typename... TYPES>
using NthType = typename NthTypeImpl<N, TYPES...>::type;

/* RetVal - Mi a függvény visszatérési értéke? */
namespace {
    template <typename T>
    class RetValImpl;

    template <typename RET, typename ... ARGS>
    class RetValImpl<RET(ARGS...)> {
        public:
            using type = RET;
    };

    template <typename CALLSIG>
    class RetValImpl<CALLSIG*> : public RetValImpl<CALLSIG> {};

    template <typename CALLSIG>
    class RetValImpl<std::function<CALLSIG>> : public RetValImpl<CALLSIG> {};
}

template <typename T>
using RetVal = typename RetValImpl<T>::type;

/* NthArg - Mi a függvény N-edik paramétere? */
namespace {
    template <unsigned N, typename T>
    class NthArgImpl;
    
    template <unsigned N, typename RET, typename ... ARGS>
    class NthArgImpl<N, RET(ARGS...)> {
        public:
            using type = NthType<N, ARGS...>;
    };

    template <unsigned N, typename CALLSIG>
    class NthArgImpl<N, CALLSIG*> : public NthArgImpl<N, CALLSIG> {};

    template <unsigned N, typename CALLSIG>
    class NthArgImpl<N, std::function<CALLSIG>> : public NthArgImpl<N, CALLSIG> {};
}

template <unsigned N, typename T>
using NthArg = typename NthArgImpl<N, T>::type;


int main() {
    /* is_same_v = C++17. Ha nem akar fordulni, akkor is_same<X, Y>::value. */
    static_assert(std::is_same_v<char, NthType<2, int, double, char>>);
    static_assert(std::is_same_v<int, RetVal<int()>>);
    static_assert(std::is_same_v<int, RetVal<int(*)()>>);
    static_assert(std::is_same_v<int, RetVal<std::function<int()>>>);
    static_assert(std::is_same_v<double, NthArg<2, void(int, char, double)>>);
}

#include <iostream>
#include <cassert>

/* Saját tuple I. */
template <typename ...>
class my_tuple;

/* üres tuple, megállítja a rekurziót */
template <>
class my_tuple<> {};

template <typename HEAD, typename ... TAIL>
class my_tuple<HEAD, TAIL...> {
  private:
    /* az első paraméternek megfelelő adat */
    HEAD data;
    /* a többi adat egy egyszerűbb tuple-ben */
    my_tuple<TAIL...> more_data;
  public:
    my_tuple() {}
    template <typename HEADP, typename ... TAILP>
    my_tuple(HEADP && head, TAILP && ... tail)
        : data(std::forward<HEADP>(head))
        , more_data(std::forward<TAILP>(tail)...) {}
    
    /* erre a my_tuple_get-nek lesz szüksége.
     * lehetne valami publikus getter is, de a rekurzív
     * példányosítás implementációs kérdés. */
    template <size_t, typename ...>
    friend class my_tuple_get;
};

/* segédosztály a my_tuple_get függvényhez,
 * mert részleges specializációra van szükség */
template <size_t IDX, typename ... TAIL>
class my_tuple_get;

template <size_t IDX, typename HEAD, typename ... TAIL>
struct my_tuple_get<IDX, HEAD, TAIL...> {
    static auto & my_get(my_tuple<HEAD, TAIL...> & t) {
        return my_tuple_get<IDX-1, TAIL...>::my_get(t.more_data);
    }
};

template <typename HEAD, typename ... TAIL>
struct my_tuple_get<0, HEAD, TAIL...> {
  public:
    static auto & my_get(my_tuple<HEAD, TAIL...> & t) {
        return t.data;
    }
};

/* a megírandó my_get függvény delegál a my_tuple_get
 * osztály statikus tagfüggvényének */
template <size_t IDX, typename ... T>
auto & my_get(my_tuple<T...> & t) {
    return my_tuple_get<IDX, T...>::my_get(t);
}

/* Saját tuple II. */
template <typename ... T>
auto my_make_tuple(T ... data) {
    return my_tuple<T...>(std::move(data)...);
}

template <typename ... T>
auto my_tie(T &... data) {
    return my_tuple<T &...>(data...);
}


int main() {
    my_tuple<int, double> t1;
    my_tuple<int, double> t2(5, 1.2);
    auto t3 = my_make_tuple(5, 1.2);
    
    my_get<0>(t1) = 2;
    std::cout << my_get<1>(t2) << std::endl;
    std::cout << my_get<1>(t3) << std::endl;
    
    int a = 2, b = 3;
    auto t4 = my_tie(a, b);
    my_get<1>(t4) = 5;
    std::cout << b;
}