LINUX.ORG.RU

g++ -E для template

 , , ,


1

6

Есть ли возможность «раскрыть» шаблоны? (не в уме).

К примеру результат препроцессора можно посмотреть g++ -E, есть ли что-то похожее для шаблонов?

К примеру:

template<typename T>
T add(T& t1, T& t2)
{
        return t1 + t2;
}
                                                                                                                     
int main()                                                                                                           
{                                                                                                                    
        int i1 = 1, i2 = 2;                                                                                          
        add(i1, i2);                                                                                                 
}

чтоб раскрылось в
int add(int& t1, int& t2)
{
        return t1 + t2;
}
                                                                                                                     
int main()                                                                                                           
{                                                                                                                    
        int i1 = 1, i2 = 2;                                                                                          
        add(i1, i2);                                                                                                 
}

★★★★

Последнее исправление: ymuv (всего исправлений: 4)

Ответ на: комментарий от buddhist

С помощью clang:

template<typename T>
T add(T& t1, T& t2)
{
        return t1 + t2;
}

template<typename T, typename V>
T add(T& t1, T& t2, V& v1, V& v2)
{
        V res = v1+v2;
        return t1 + t2;
}

int main() 
{
        int i1 = 1, i2 = 2;
        float f1 = 1.1, f2 = 1.2;
        add(i1, i2);
        add(i1, i2, i1, i2);

        add(i1, i2, f1, f2);
}



$ clang++ -cc1 -ast-print 1.cpp | sed 's/template <typename .* = .*>//g'


 int add(int &t1, int &t2) {
    return t1 + t2;
}

template <typename T> T add(T &t1, T &t2) {
    return t1 + t2;
}

;
 int add(int &t1, int &t2, int &v1, int &v2) {
    int res = v1 + v2;
    return t1 + t2;
}

 int add(int &t1, int &t2, float &v1, float &v2) {
    float res = v1 + v2;
    return t1 + t2;
}

template <typename T, typename V> T add(T &t1, T &t2, V &v1, V &v2) {
    V res = v1 + v2;
    return t1 + t2;
}

;
int main() {
    int i1 = 1, i2 = 2;
    float f1 = 1.1000000000000001, f2 = 1.2;
    add(i1, i2);
    add(i1, i2, i1, i2);
    add(i1, i2, f1, f2);
}


Но все пути к инклудам (в том числе с /usr/include) нужно задавать вручную. Возможно есть другие проблемы, но на простых файлах (без инклудов) работает нормально.

ymuv ★★★★
() автор топика
Ответ на: комментарий от ymuv

Для g++ вывод не такой красивый

template<typename T>
T add(T& t1, T& t2)
{
        return t1 + t2;
}

template<typename T, typename V>
T add(T& t1, T& t2, V& v1, V& v2)
{
        V res = v1+v2;
        return t1 + t2;
}

template<typename T, typename V, typename T1>
T add(T& t1, T& t2, V& v1, V& v2, T1& )
{
        V res = v1+v2;
        return t1 + t2;
}

class A {};

template double add<double>(double&, double&);
//template A add<A>(A&, A&);
int main()
{
        int i1 = 1, i2 = 2;
        float f1 = 1.1, f2 = 1.2;
        A a1;
        add(i1, i2);
        add(i1, i2, i1, i2);

        add(i1, i2, f1, f2, a1);
}

g++ -fdump-tree-original 1.cpp [/qoute]


;; Function int main() (null)
;; enabled by -tree-original


{
  int i1 = 1;
  int i2 = 2;
  float f1 = 1.10000002384185791015625e+0;
  float f2 = 1.2000000476837158203125e+0;
  struct A a1;

  <<cleanup_point   int i1 = 1;>>;
  <<cleanup_point   int i2 = 2;>>;
  <<cleanup_point   float f1 = 1.10000002384185791015625e+0;>>;
  <<cleanup_point   float f2 = 1.2000000476837158203125e+0;>>;
    struct A a1;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) add<int> ((int &) &i1, (int &) &i2) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) add<int, int> ((int &) &i1, (int &) &i2, (int &) &i1, (int &) &i2) >>>>>;
  <<cleanup_point <<< Unknown tree: expr_stmt
  (void) add<int, float, A> ((int &) &i1, (int &) &i2, (float &) &f1, (float &) &f2, (struct A &) &a1) >>>>>;
}
return <retval> = 0;


;; Function T add(T&, T&) [with T = double] (_Z3addIdET_RS0_S1_)
;; enabled by -tree-original

return <retval> = *t1 + *t2;


;; Function T add(T&, T&) [with T = int] (null)
;; enabled by -tree-original

return <retval> = *t1 + *t2;


;; Function T add(T&, T&, V&, V&) [with T = int; V = int] (null)
;; enabled by -tree-original

{
  int res = *v1 + *v2;

    int res = *v1 + *v2;
  return <retval> = *t1 + *t2;
}


;; Function T add(T&, T&, V&, V&, T1&) [with T = int; V = float; T1 = A] (null)
;; enabled by -tree-original

{
  float res = *v1 + *v2;

    float res = *v1 + *v2;
  return <retval> = *t1 + *t2;
}

ymuv ★★★★
() автор топика

Не знаю, зачем тебе это, но если ты хочешь дебажить темлейты, то есть очень удобный REPL: metashell.

Kuzy ★★★
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.