ZFX + Developia

Code: Alles auswählen

#include <iostream>
 
#define con_do(a, b) a, b
#define con(a, b) con_do(a, b)
#define onetwo 1, 2
#define threefour 3, 4
 
void foo(int a, int b, int c, int d)
{
    std::cout << a << b << c << d;
}
 
int main()
{
    // MSVC ersetzt "korrekt", GCC meldet Fehler, weil der Standard
    // die Expansion von a und b bereits in con vorschreibt
    foo( con(onetwo, threefour) );
    return 0;
}

Code: Alles auswählen

#include <iostream>
 
#define assert_no_va_args()
#define con_do(a, b) a, b
#define con(a, b, ...) con_do(a##__VA_ARGS__, b##__VA_ARGS__) assert_no_va_args(__VA_ARGS__)
#define onetwo 1, 2
#define threefour 3, 4
 
void foo(int a, int b, int c, int d)
{
    std::cout << a << b << c << d;
}
 
int main()
{
    // MSVC ersetzt "korrekt", GCC meldet Fehler, weil der Standard
    // die Expansion von a und b bereits in con vorschreibt
    foo( con(onetwo, threefour) );
    return 0;
}

Code: Alles auswählen

// Funktionstemplates
template <class X> X foo(int, float);
template <class X> Y<X> bar(X&);
// mehr Templates ...

void absorb(...) { }
typedef void (*absorbfun)();

// Intantiierungsfunktion
template <class X>
void InstantiateXFunctions()
{
   absorb
   (
      (absorbfun) foo<X>,
      (absorbfun) bar<X>,
      // mehr Templates ...
   );
}

// Intantiierung für bestimmte Typen
template void InstantiateXFunctions<Baz>();
template void InstantiateXFunctions<Fam>();

Code: Alles auswählen

template <typename T> void f();
template <typename T> int g();

template <typename T>
class InstantiateStuff
{
  friend void f<T>();
  friend int g<T>();
};

Code: Alles auswählen

struct Foo { };

template <class Foo>
struct Bar : public ::Foo
{
    typedef Foo foo;
};

Bar<int>::foo i = 2; // Fehler: foo hat Typ ::Foo, injizierter Typname der Basisklasse verdeckt Template-Parameter

Code: Alles auswählen

template <class X>
struct Foo { };
 
template <class X>
struct Bar : public Foo<X>
{
//  typedef Foo foo; geht nicht, da Foo in Foo<X> injiziert wurde, der Inhalt
//  von Foo<X> jedoch erst zum Instantiierungszeitpunkt von Bar bekannt wird

    // Deshalb geht jedoch folgendes, womit sich ein Haufen Redundanz loswerden lässt:
    typedef typename Bar::Foo foo;
};