Сегодня мы с вами поговорим о любви C/C++ к Java. Связь не очевидна, но она есть. Итак, поехали!

В прошлый раз мы с вами говорили об обратной задаче, а стоило ли когда-нибудь выполнять эту?

Очевидно, что и такое нам тоже нужно, когда например нашему методу передаётся объект, который предоставляет нам какие-то услуги, которые мы в свою очередь должны выполнить. Ну или опять банальный пример, нам попросту нужно вызывать выполнять некоторые задачи из другого проекта в среде своего проекта.

Рассмотрим опять что-нибудь незамысловатое, чтобы не пудрить сильно мозги.

Допустим, у нас есть Java класс, в котором реализован метод, который приветствует другой объект. Вот как выглядит класс с методом:

public class Hello {
      public static int HelloObject(PeopleObject people)  {
	    System.out.println("Height" + people.height);
	    System.out.println("Name:" + people.name);
	    System.out.println("Town:" + people.town);
	    System.out.println("Age:" + people.age);
	    return OK;
	}
}

Вот как выглядит сам класс:

public class PeopleObject {
	public int height;
	public String name;
	public String town;
	public int age;
	public PeopleObject(int height, String name, String town, int age) {
		this.height = height;
		this.name = name;
		this.town = town;
		this.age = age;
	}
}

Со стороны Java всё готово, теперь подготовим площадку в C/C++, для вызова нашего метода.

Для того что бы вызвать наш метод из C/C++, вначале нам понадобится загрузить (создать) JVM (виртуальную Java машину) используя следующее:

JNIEnv * loadJVM(JavaVM ** jvm) {
    JavaVMOption jvmOptions;
    jvmOptions.optionString = "-Djava.class.path=C:\\JavaClassFiles";
    JavaVMInitArgs jvmArgs;
    jvmArgs.version = JNI_VERSION_1_6;
    jvmArgs.nOptions = 1;
    jvmArgs.options = &jvmOptions;
    jvmArgs.ignoreUnrecognized = JNI_TRUE;
    JNIEnv * env;
    int OK = JNI_CreateJavaVM(jvm, (void**)&env, &jvmArgs);
    if(OK < 0) printf("\nUnable to Launch JVM\n");
    return env;
}

Итак, по порядку:
jvmOptions.optionString = "-Djava.class.path=C:\\JavaClassFiles";
в этой строке мы указываем папку исходников, где располагаются файлы классов. Далее jvmArgs описывает аргументы для вызова Java машины.

jvmArgs.version = JNI_VERSION_1_6;
jvmArgs.nOptions = 1;
jvmArgs.options = &jvmOptions;
jvmArgs.ignoreUnrecognized = JNI_TRUE;

в первой строчке мы задаём версию Java, во второй мы задаём кол-во опций, так как они хранятся в массиве, в данном случае мы задаём опцию для Java машины, и в четвёртой строке мы указываем игнорировать все нераспознанные опции, строка которых начинается с "-X" or "_" (Не обязательно).

Теперь вызовем создание Java машины:

JNIEnv *env;
JavaVM * jvm;
env = loadJVM(&jvm);
if (env == NULL) return BAD;

А теперь всё готово для начала работы с Java методами, объектами. Для начала найдём два наших класса:

jclass clsH = env->FindClass("Hello");
jclass clsP = env->FindClass("PeopleObject");

Метод “FindClass” ищет класс по имени.

Теперь у класса “Hello”, получим метод “HelloObject”.

jmethodID midHelloObject = NULL;
if (clsH != NULL)  {
	midHelloObject = env->GetStaticMethodID(clsH,"HelloObject","(LPeopleObject;)I");
} else {
    	printf("\nUnable to find the requested class\n");
}

Тут тоже всё довольно понятно, по сути, мы просто работаем со всеми методами, только через сторонний интерфейс.

Метод GetStaticMethodID ищет метод в классе clsH с именем HelloObject и нужной сигнатурой. О том как генерировать сигнатуру не ручками, скажем позже.

Теперь получим конструктор класса “PeopleObject”, для того, чтобы в него передать нужные параметры для создания объекта.

jmethodID midPeopleObjectConst = NULL;
if(clsP != NULL)  	{
	midPeopleObjectConst = env->GetMethodID(clsP, "<init>", "(ILjava/lang/String;Ljava/lang/String;I)V");
} else  {
	printf("\nUnable to find the requested class\n");
}

Словом "<init>" мы показываем, что это будет именно конструктор.
Ну а теперь сделаем то, что задумали:

jobject jobjPeople = NULL;
if (midHelloObject!=NULL)  {
	if(clsP != NULL && midHelloObjectConst != NULL)  {
		char  cName[255] = “Yuki”;
		jstring name = env->NewStringUTF(cName);
		char  cTown[255] = “Tokyo”;
		jstring town = env->NewStringUTF(cTown);
		int cHeight = 169;
		jint height = (jint) cHeight;
		int cAge = 17;
		jint age = (jint) cAge;
		jobjPeople = env->NewObject(clsP, midPeopleObjectConst, height, name, town,  age);
	}
	if(jobjPeople != NULL && midHelloObject!= NULL)
		env->CallStaticIntMethod(clsH,midHelloObject,jobjPeople);
}

Что тут происходит? Да всё то же самое, подготавливаются параметры для создания объекта PeopleObject. Далее создаётся объект класса PeopleObject через его конструктор. А дальше вызывается метод из класса Hello, с передачей в функцию HelloObject, объекта класса PeopleObject.

Ну и в конце не забываем уничтожить Java машину: jvm->DestroyJavaVM();

Вот и всё

Ах, да, как же генерировать правильно сигнатуру? Это можно делать и руками, но можно легко ошибиться, да и очень много работы. Генерировать сигнатуры можно при помощи утилиты “javap”, входящей в состав JDK. Например, если запустить её для класса “Hello” (javap -s -p Hello), то мы получим:

//Compiled from "Hello.java"
public class Hello extends java.lang.Object{
public Hello ();
  	Signature: ()V
public static void main(java.lang.String[]);
  	Signature: ([Ljava/lang/String;)V
public static int HelloObject(PeopleObject);
  	Signature: (LPeopleObject;)I
}

Cкажу напоследок, что если у вас 64-битная архитектура, то у вас возможно возникнут проблемы с компиляцией и запуском приложения. Дело в том что JDK 64-bit поставляет не совсем пригодные для таких операций библиотеки, поэтому лучше скачать JDK 32-bit и подключать либы оттуда.

Теперь мы показали взаимную любовь Java & C/C++, и можно за них порадоваться
Подробнее обо всё можно почитать по-прежнему на сайте Oracle.

Сегодня мы с вами поговорим о любви Java к C++. Связь не очевидна, но она есть. Итак, поехали!

Порой в нашей жизни требуется использовать код, написанный на другом языке. Опишем несколько случаев такой необходимости:

• Пускай у вас есть проверенный на 100% код на другом языке. Для того что бы его перевести на язык Java, потребуется немало времени, а полученный код нужно опять проверять и отлаживать. Особенно если это огромная библиотека или проект.
• Или нам нужны низкоуровневые операции для доступа к аппаратным средствам, в таком случае Java не очень подходит для таких операций.
• Или если нам нужно множественное применение сложных операций с машиной, требующих очень оптимизированного кода, чего на Java опять не добьёшься (хотя этому можно поставить в противовес just-in-time компиляцию).

Если мы всё же столкнулись с одной из вышеперечисленных проблем, то, скорее всего нам-таки придётся научиться вызывать платформенно-ориентированный код прямиком из Java. Для этого в Java предусмотрены специальные способы работы с системными библиотеками, а JDK содержит инструменты, которые позволят нам справиться с этими проблемами.

Конечно, всё это не избавляет нас от полноценного решения, так как для каждой операционной системы потребуются библиотеки, ориентированные именно на эту среду, и хоть и Java очень хорошо контролируемый язык, то C++ в свою очередь неконтролируем, поэтому возможно, что методы из C++ выведут из строя виртуальную Java-машину, либо вызовет сбой системы или ещё что-нибудь.

Но выбор за вами, стоит ли это делать в ситуации, с которой вы столкнулись или нет

Я не буду описывать кучу методов, кучу ситуаций, и тому подобное, это лучше всего расскажет специализированная книжка, а тут будет приведены примеры почти стандартных задач, вида Hello “damn” world!

Итак, наша задача: на языке C/C++ есть функция, которая выполняет какие-то сумасшедше-полезные действия. И мы хотим её вызвать из Java (да-да, нам лень переписать её на Java ). Пускай это функция вывода printf (можно использовать и другие, но будем ориентироваться на C), которая приветствует передаваемую строку и какое-то число.

Для того, чтобы в Java показать, что функция будет платформенно-ориентированной, есть ключевое слово “native”, которое предупреждает компилятор о внешнем определении данного метода. Саму функцию нужно описывать в классе.

public static native void welcome(String str, int value);

В данном случае функция объявлена как статическая, но это не обязательное условие. Теперь поместим её в класс:

class Hello {
      public static native void welcome(String str, int value);
}

Такой класс откомпилировать вы сможете, но вылетит исключение, говорящее, что программа не может найти метод. Для того? чтобы метод был найден, его тело нужно создать на C/C++, причём не просто метод, а метод говорящий что его будут вызывать из кода на Java. Но об этом попозже, просто знайте, что мы создадим разделяемую библиотеку для экспорта на C/C++, а далее загрузим её в Java. И только тогда программа найдёт этот метод и сможет успешно выполняться.

Библиотеку удобнее всего подключить в статическом блоке, чтобы при вызове функции, она уже была подгружена. И вот что получается:

class Hello {
   public static native void welcome(String str, int value);
   static  {
      System.loadLibrary("JAVALOVECHELLO");
   }
}

Метод loadLibrary("JAVALOVECHELLO"), загружает библиотеку по имени JAVALOVECHELLO.

Теперь настало время для создания C/C++ функции, имя которой должно строго (значит точно) соответствовать соглашениям об именовании:

• Имя метода в C/C++ должно полностью соответствовать ПОЛНОМУ имени в Java программе. Например, если мы поместим программу в пакет com.intel, тогда полное имя Java-метода будет com.intel.Hello.welcome. Теперь нужно заменить все точки на нижние подчёркивания (_) и добавить префикс “Java_”, получим строку Java_com_intel_Hello_welcome. Если код находится в пакете “default”, то имя C-функции должно выглядеть так: Java_Hello_welcome.
• Стоит быть внимательными с различными Unicode-символами: их нужно заменять на их 16-ричное представление, но об этом не будем тут. На самом деле и это ещё не все соглашения, но сейчас расскажем, как не делать этого ручками.

Для правильно описанных методов не стоит их создавать руками, для этого воспользуемся специальной утилитой “javah”, которая есть в JDK. Для начала откомпилируем наш Java-файл, используя “javac”.

javac Hello.java

Теперь воспользуемся “javah”.

javah Hello

В результате выполнения этих операций мы получим файл “Hello.h”

/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class Hello */
#ifndef _Included_Hello
#define _Included_Hello
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     Hello
 * Method:    welcome
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_Hello_welcome
  (JNIEnv *, jclass, jstring, jint);
#ifdef __cplusplus
}
#endif
#endif

Как видно, так как мы пишем на C++, то добавлена строчка extern "C", которая об этом сообщает. Имена JNIEXPORT и JNICALL описаны в jni.h, они задают спецификаторы функций, экспортируемых из динамических библиотек .

В данном файле всё довольно понятно, всё как мы и предполагали (на самом деле не всё, но об этом позже).

Осталось для данного файла заголовка написать соответствующий файл c исходным кодом, где мы и опишем тело метода.

Вот как он будет выглядеть:

#include "Hello.h"
#include
JNIEXPORT void JNICALL Java_Hello_welcome(JNIEnv* env, jclass cl, jstring str, jint value)
{
   const char * ccstr;
   ccstr = (*env).GetStringUTFChars(str, NULL);
   printf("Hello damn World, %s, %d!\n", ccstr, (int)value);
}

Во всех вызовах JNI-функций есть указатель env, который является первым параметром любого платформенно-ориентированного метода. Параметр env указывает на таблицу функций, содержащую указатели функций.

Как наверно можно догадаться jstring, jint это по сути те же string, int, но только в понимании JNI (их соответствия).

Функция GetStringUTFChars() возвращает указатель const jbyte * на символы строки, представленные в формате UTF-8. Также не помешает после использования строк освобождать память. Если же этого не делать, то это может повлиять на работу метода (память не безгранична). Для этих целей нужно использовать метод ReleaseStringUTFChars().

Очень подробное описание всех функций (API JNI) можно найти сайте Oracle, по этой ссылке - http://docs.oracle.com/javase/6/docs/technotes/guides/jni/spec/jniTOC.html.

Как компилировать динамическую библиотеку каждый выбирает сам, это можно сделать вручную, или можно предоставить всё MVS.

Нужные вам библиотеки, необходимые для успешной компиляции C/C++, лежат в JDK/include.

Ну и осталось написать вызов функции из Java-программы:

class HelloTest {
   public static void main(String[] args)    {
      Hello.welcome("I'm a string", 100500);
   }
}

На этом закончим, хоть и было рассмотрено материала 7% от общего, но тут главное смысл, а дальше уже как по маслу, берёшь и намазываешь

Много ли ваших программ выполняет свою работу, и считает ответ уже на этапе компиляции? Сегодня я в минимуме описания и массе примеров, покажу как и что работает.

Сразу скажу, кто знаком с темой может дальше не читать. Эта тема, да и не только она, очень очень глубоко рассматривается в книге Александреску в «Современное проектирование на С++». Лично я её сам почти не читал, но в плане пошевелить левой и правой долей мозга она поможет, может запутать, а может и распутать что-нибудь этакое! Поехали!

Итак, списки типов... предоставляют собой средство для манипулирования коллекциями типов.

Начнём с простейшего, и постепенно будем увеличиваться.

Просто список

Определим список типов, его общий вид:

template<typename T, typename U>
struct TypeList
{
    T Head;		//Голова
    U Tail;		//Хвост
};

Те, кто знаком с шаблонами, знают, что теперь мы можем передавать любые типы в список, это и будут наши типы.
В данном определении видно, что у нас хвост и голова это два неких типа.

Пусть голова определяет тот тип, который сейчас стоит вначале, а хвост определяет список, идущий после головы, т.е в хвосте, будет своя голова и свой хвост, и т.д.. Но нужно как то признак конца. Для этого мы создадим пустой список (аналог NULL), который и будет сообщать, что список закончился.

Итак, определим ещё некоторые вещи.

Создание списка из трёх разных типов:

typedef TypeList<int, TypeList<double, char> > someTypeList;

Теперь пустой список:

struct NullType {};

Описание списка из одного элемента:

typedef TypeList<int, NullType> onlyType;

Вы заметили, что описание списка из 7 элементов будет довольно некомпактным? Не беда, в с++ есть #define!
И вот как мы поступим. Вначале список длины 1:

#define TYPELIST_1(T01)	TypeList<T01, NullType>

Теперь длины 2:

#define TYPELIST_2(T01, T02) TypeList<T01, TYPELIST_1(T02) >

Понятно, да?

#define TYPELIST_1(T01)	TypeList<T01, NullType>
#define TYPELIST_2(T01, T02) TypeList<T01, TYPELIST_1(T02) >
#define TYPELIST_3(T01, T02, T03) TypeList<T01, TYPELIST_2(T02, T03) >
#define TYPELIST_4(T01, T02, T03, T04) TypeList<T01, TYPELIST_3(T02, T03, T04) >
#define TYPELIST_5(T01, T02, T03, T04, T05) TypeList<T01, TYPELIST_4(T02, T03, T04, T05) >
#define TYPELIST_6(T01, T02, T03, T04, T05, T06) TypeList<T01, TYPELIST_5(T02, T03, T04, T05, T06) >
#define TYPELIST_7(T01, T02, T03, T04, T05, T06, T07) TypeList<T01, TYPELIST_6(T02, T03, T04, T05, T06, T07) >

Теперь создадим список из трёх элементов:

typedef TYPELIST_3(int, double, float) someTypeList;

Ну вот, стало попроще.

Итак, пора бы придумать кучу задач на списки типов (думаете это нереально? ), и сделать так, что бы всё это отрабатывало во время компиляции с хорошей скоростью.

Дальше пойдут различные условия, что нужно сделать со списком типов, и решение, придуманное на ходу (так оно и было!), и описанное, так сказать, в свободной форме. Поехали!

Как же с коллекцией чего-то, да без длины! Непорядок!

Длина списка

template<class TList>
struct Length;

template<>
struct Length
{
    enum { value = 0 };
};

template<typename Head, typename Tail>
struct Length<TypeList<Head, Tail> >
{
    enum {value = 1 + Length<Tail>::value };
};

Длина нулевого списка типов равна 0.
Длина любого другого списка типов равна 1 плюс длина его оставшейся части.
Но в итоге получаем, на этапе компиляции, статическую константу, равную длине списка типов

enum {value = 1 + Length<Tail>::value };

Тут мы хитрим, используя тип перечисления enum, int и прочие типы тут использовать нельзя, так же забудьте про if, и остальное, но не забывайте про конструкцию вида (ok) ? A : B;

template<typename Head, typename Tail>
struct Length<TypeList<Head, Tail> >
{
    enum {value = 1 + Length&ltTail&gt::value };
};

Вот это общий метод вычисления длины, когда ещё есть и начало, и хвост, поступаем, как описано, было выше.

template<>
struct Length<NullType>
{
    enum { value = 0 };
};

Тут уже идёт специализация, ибо мы хотим заходить сюда, только в случае, если список стал пустым (помните NullType), ну и понятно, что его длина равна 0.

template<class TList>
struct Length;

А это общее описание, без тела.

Всё остальные задачки, будут выглядеть примерно так же, общий метод, специализации и общее описание.

Ну и покажем, как же теперь вычислить длину списка:

int x = Length< TYPELIST_3(int, double, string) >::value;
cout >> x >> endl;

Отлично, вот и первая задачка решена!

Индексированный доступ:

Если индекс i больше чем кол-во элементов в списке, то возвращается тип по умолчанию, иначе возвращается тип, стоящий на позиции i в списке.
Как только i стало равно 0, значит, что мы дошли до нужного типа, возвращаем Head, иначе, если i станет отрицательным, т.е. не подойдёт ни под одну специализацию, возвратится тип по умолчанию, в общем случае, мы уменьшаем i и двигаемся вправо по списку.

template<typename TList, std::size_t i, typename DefT = NullType>
struct TypeAt
{
    typedef DefT Result;
};

template<typename Head, typename Tail, typename DefT>
struct TypeAt<TypeList<Head, Tail>, 0, DefT>
{
    typedef Head Result;
};

template<typename Head, typename Tail, std::size_t i, typename DefT>
struct TypeAt<TypeList<Head, Tail>, i, DefT>
{
    typedef typename TypeAt<Tail, i - 1, DefT>::Result Result;
};

Использование:

TypeAt<TYPELIST_3(int, char, string), 1>::Result someTypeA;
TypeAt<TYPELIST_3(int, double, string), 5, int>::Result someTypeB;
cout << someTypeA << endl; // char
cout << someTypeB << endl; // int

Вычисление индекса типа в списке.

Бежим по списку, если список стал пустым, то значит тип не найден, возвращаем -1. Если мы встали на нужный нам тип, то начинаем считать какой же это номер, начиная с него. Поэтому value = 0, так как мы бежим назад теперь, это ведь как рекурсия и прибавляем по +1, если же у нас получился -1, то операция +1, будет -1 оставлять -1, что бы в итоге получилось -1 и стало понятно, что ничего не найдено.

template<typename TList, typename T>
struct IndexOf;

template<typename T>
struct IndexOf<NullType, T>
{
    enum { value = -1 };
};

template<typename T, typename Tail>
struct IndexOf<TypeList<T, Tail>, T>
{
    enum { value = 0 };
};

template<typename Head, typename Tail, typename T>
struct IndexOf<TypeList<Head, Tail>, T>
{
private:
    enum { temp = IndexOf<Tail, T>::value };
public:
    enum { value = ((temp == -1) ? -1 : 1 + temp) };
};

Применение:

int y = IndexOf<TYPELIST_3(int, double, string), double>::value;
int z = IndexOf<TYPELIST_3(int, double, string), float>::value;
cout << y >> endl; // 1
cout << z >> endl; // -1

Наверно уже пора всё таки узнавать, а что же мы получаем?

Для этого мы хотим распечатать наш список, да без проблем!

template <typename T>
void FPrint()
{
    cout << typeid(T).name() << endl;
}

template <typename TList> struct KPrint;

template <typename Head, typename Tail>
struct KPrint<TypeList<Head, Tail> >
{
    static void Print()
    {
        FPrint<Head>();
        KPrint<Tail>::Print();
    }
};

template <>
struct KPrint<NullType>
{
    static void Print()
    {
        cout << "==== End of list ====nn";
    }
};

Тут всё просто, бежим по порядку, и каждый элемент выводим на печать.

KPrint<TYPELIST_3(int, char, byte)>::Print(); // int char byte

А теперь начнём массовое уничтожение мозга!

Соединение двух списков в один

Второй дописывается в конец:
Если первый список пустой, а второй является списком, то их объединение это и есть второй список.
Если первый список пустой, а второй является элементом (т.е 1 типов), то их объединение это список из 1 типа.
Если первый список не пустой, то их объединение это голова первого списка + объединение хвоста со вторым списком.

template<typename TListA, typename TListB>
struct Append;

template<>
struct Append<NullType, NullType>
{
    typedef NullType Result;
};

template <typename T>
struct Append<NullType, T>
{
    typedef TypeList<T, NullType> Result;
};

template<typename Head>
struct Append<NullType, TypeList<Head, NullType> >
{
    typedef TypeList<Head, NullType> Result;
};

template<typename Head, typename Tail, typename T>
struct Append<TypeList<Head, Tail>, T >
{
    typedef TypeList<Head, typename Append<Tail, T>::Result > Result;
};

template<typename Head, typename Tail>
struct Append<NullType, TypeList<Head, Tail> >
{
    typedef TypeList< Head, Tail > Result;
};

Использование:

typedef Append< TYPELIST_3(int, double, long double), TYPELIST_3(float, char, short) >::Result typeAppend;
// int, double, long double, float, char, short

Замена всех типов стоящих на чётных/нечётных местах, на другой тип.

Тут мы поступим элегантным способом, заведем дополнительный параметр, который принимает значения 0 или 1, если параметр равен 1, то значит, текущий элемент нужно заменить, и переходим дальше с параметром 0, иначе если 0 то заменять не нужно, и переходим с состоянием 1. И если запустить с параметром 0, то меняться начнут 1, 3, ..., иначе 0, 2, ... Так же параметр по умолчанию равен 0, поэтому можно 0 и не передавать.

template<typename TList, typename U, std::size_t index = 0>
struct ReplaceEvenOdd {
    typedef TList Result;
};

template<typename U>
struct ReplaceEvenOdd<NullType, U>
{
    typedef NullType Result;
};

template <typename Head, typename Tail, typename U>
struct ReplaceEvenOdd<TypeList<Head, Tail>, U, 1>
{
    typedef TypeList<U, typename ReplaceEvenOdd<Tail, U, 0>::Result> Result;
};

template <typename Head, typename Tail, typename U>
struct ReplaceEvenOdd<TypeList<Head, Tail>, U, 0>
{
    typedef TypeList<Head, typename ReplaceEvenOdd<Tail, U, 1>::Result> Result;
}; 

Применение:

typedef ReplaceEvenOdd<TYPELIST_5(int, char, double, short, float), long long>::Result typeReplaceEven;
typedef ReplaceEvenOdd<TYPELIST_5(int, char, double, short, float), long long, 1>::Result typeReplaceOdd;

Удаляем первый найденный тип, совпадающий с заданным.

Бежим пока не встретим наш заданный тип, если в итоге не встретили, то ничего и не изменится, иначе возвращается остаток списка без головы.

template <class TList, class T>
struct EraseFirst;

template <class T>
struct EraseFirst<NullType, T>
{
    typedef NullType Result;
};

template <class T, class Tail>
struct EraseFirst<TypeList<T, Tail>, T>
{
    typedef Tail Result;
};

template <class Head, class Tail, class T>
struct EraseFirst<TypeList<Head, Tail>, T>
{
    typedef TypeList<Head, typename EraseFirst<Tail, T>::Result> Result;
};

Применение:

typedef EraseFirst<TYPELIST_4(int, double, char, double), double>::Result typeEraseFirst;

Удаляем все типы, совпадающие с заданным.

Задача почти такая же, как и предыдущая, только когда мы обнаруживаем наш тип, мы не возвращаем хвост без головы, а возвращаем то, что останется от головы после удаления в ней всех типов совпадающих с заданным.

template <class TList, class T>
struct EraseAll;

template <class T>
struct EraseAll<NullType, T>
{
    typedef NullType Result;
};

template <class T, class Tail>
struct EraseAll<TypeList<T, Tail>, T>
{
    typedef typename EraseAll<Tail, T>::Result Result;
};

template <class Head, class Tail, class T>
struct EraseAll<TypeList<Head, Tail>, T>
{
    typedef TypeList<Head, typename EraseAll<Tail, T>::Result> Result;
};

Применение:

typedef EraseAll<TYPELIST_5(int, double, char, double, short), double>::Result typeEraseAll;

Удаляем все дубликаты типов.

Тут всё интересней. Допустим мы, сейчас имеем список, тогда отщепим от него голову, удалим все дубликаты в хвосте, а теперь в том, что получилось, удалим первый тип, совпадающий с головой, и присоединим все, что осталось к голове. Это и будет ответом для текущего списка. Ну, смотрите, раз мы удалили все дубликаты в хвосте, то понятное дело все типы там встречаются по 1 разу, значит если там есть голова, то она тоже встречается 1 раз, когда мы запустим удаление головы, она станет встречаться там 0 раз, следовательно присоединив это всё к голове, у нас не будет дубликатов!

template <class TList>
struct EraseDuplicates;

template <>
struct EraseDuplicates<NullType>
{
    typedef NullType Result;
};

template <class Head, class Tail>
struct EraseDuplicates<TypeList<Head, Tail>>
{
    private:
        typedef typename EraseDuplicates<Tail>::Result L1;
        typedef typename EraseFirst<L1, Head>::Result L2;

    public:
        typedef TypeList<Head, L2> Result;
};

Применение:

typedef EraseDuplicates< TYPELIST_7(int, double, char, double, int, char, char)>::Result typeEraseDuplicates; // int double char

Напоминаю, что это всё работает ещё на этапе компиляции. Ощущение что до сюда мало кто дошёл, но моё дело писать, писать, писать! Поехали дальше!

Замена первого найденного заданного типа, на заданный тип.

Тут почти, как и при удалении, так что объяснение излишне.

template <class TList, class T, class U>
struct ReplaceFirst;

template <class T, class U>
struct ReplaceFirst<NullType, T, U>
{
    typedef NullType Result;
};

template <class T, class Tail, class U>
struct ReplaceFirst<TypeList<T, Tail>, T, U>
{
    typedef TypeList<U, Tail> Result;
};

template <class Head, class Tail, class T, class U>
struct ReplaceFirst<TypeList<Head, Tail>, T, U>
{
    typedef TypeList<Head, typename ReplaceFirst<Tail, T, U>::Result> Result;
};

Замена всех типов совпадающих с заданным, на другой заданный тип.

Опять, как и при удалении.

template <class TList, class T, class U>
struct ReplaceAll;

template <class T, class U>
struct ReplaceAll<NullType, T, U>
{
    typedef NullType Result;
};

template <class T, class Tail, class U>
struct ReplaceAll<TypeList<T, Tail>, T, U>
{
    typedef TypeList<U, typename ReplaceAll<Tail, T, U>::Result> Result;
};

template <class Head, class Tail, class T, class U>
struct ReplaceAll<TypeList<Head, Tail>, T, U>
{
    typedef TypeList<Head, typename ReplaceAll<Tail, T, U>::Result> Result;
};

Переворот списка.

Тут нам поможет ранее написанный Append.
Да кстати, уже не уделяю внимание отдельным случаям (специализациям), ибо они очевидны, это крайние случаи, и как поступать с ними, тоже вполне легко понять. Итак, берём голову, и присоединяем её к перевернутому хвосту, и всё!

template <class TList>
struct Reverse;

template <>
struct Reverse<NullType>
{
    typedef NullType Result;
};

template <class Head, class Tail>
struct Reverse<TypeList<Head, Tail>>
{
    typedef typename Append<typename Reverse<Tail>::Result, Head>::Result Result;
};

Применение:

typedef Reverse<TYPELIST_5(int, double, char, bool, float)>::Result typeReverse;
// float bool char double int

Вставка данного типа после всех типов с номерами n + km, по данным m, n.

Весело, не правда ли?
Тут поступаем так: вначале уменьшаем постепенно n, ну и отщепляя каждый раз голову, когда n = 0, означает что нужно вставить сюда, вставляем, и прибавляем то, что станет с головой, после запуска вставки в ней на место n передается m, следовательно, автоматически следующий элемент вставиться после m, а дальше опять после m и т.д. Это как раз и есть n + km.

template <typename TList, typename T, std::size_t IndexM, std::size_t IndexN>
struct InsertAfterNstepM
{
    typedef TList Result;
};

template <typename T, std::size_t IndexM, std::size_t IndexN>
struct InsertAfterNstepM<NullType, T, IndexM, IndexN>
{
    typedef NullType Result;
};

template <typename Head, typename Tail, typename T, std::size_t IndexM>
struct InsertAfterNstepM<TypeList<Head, Tail>, T, IndexM, 0>
{
    typedef TypeList<Head, TypeList<T, typename InsertAfterNstepM<Tail, T, IndexM, IndexM - 1>::Result>> Result;
};

template <typename Head, typename Tail, typename T, std::size_t IndexM, std::size_t IndexN>
struct InsertAfterNstepM<TypeList<Head, Tail>, T, IndexM, IndexN>
{
    typedef TypeList<Head, typename InsertAfterNstepM<Tail, T, IndexM, IndexN - 1>::Result> Result;
};

Применение:

typedef InsertAfterNstepM<TYPELIST_7(int, double, char, int, float, char, short), bool, 1, 1>::Result typeInsertAfterNstepM;

Удаление всех типов с номерами n + km, по данным m, n

Поступаем, так же как и в предыдущем примере.

template <typename TList, std::size_t IndexM, std::size_t IndexN>
struct EraseNstepM
{
    typedef TList Result;
};

template <std::size_t IndexM, std::size_t IndexN>
struct EraseNstepM<NullType, IndexM, IndexN>
{
    typedef NullType Result;
};

template <typename Head, typename Tail, std::size_t IndexM>
struct EraseNstepM<TypeList<Head, Tail>, IndexM, 0>
{
    typedef typename EraseNstepM<Tail, IndexM, IndexM - 1>::Result Result;
};

template <typename Head, typename Tail, std::size_t IndexM, std::size_t IndexN>
struct EraseNstepM<TypeList<Head, Tail>, IndexM, IndexN>
{
    typedef TypeList<Head, typename EraseNstepM<Tail, IndexM, IndexN - 1>::Result> Result;
};

Разделение списка на две половины, первая до [Длина списка] / 2, во второй всё оставшееся.

Тут всё немножко больше и сложнее для понимая.

Во-первых, у нас будет всё передаваться в Partion, который по сути сам не разделяет два списка, а обрабатывает отдельные случаи и говорит, как поступить вспомогательному PartionH, который как раз и делит, передав в него два раза один и тот же список. Сейчас объясню, для чего это делается.

Имея два одинаковых списка, мы в одном будем бежать со скоростью 1, а во втором со скоростью 2, т.е. отщепливать по 1, или по два символа. Понятно, что когда во втором списке останется 1 либо 0 элементов, то всё, что осталось в первом списке, будет являться второй половиной, смотрите:

List1: 12345 -> 2345 -> 345
List2: 12345 -> 345 -> 5

Значит вторая половина это 345.

А теперь возвращаясь назад по рекурсии мы к первому списку начнём приписывать в начало элементы, которые откинулись, т.е NullType -> 2 -> 12. Итого, получаем разбиение 12 | 345.

Для полного понимания лучше нарисовать на листочке и проделать несколько примеров.

template <typename TList1, typename TList2>
struct PartitionH;

template <typename Head, typename Tail>
struct PartitionH<TypeList<Head, Tail>, NullType>
{
    typedef NullType Result1;
    typedef TypeList<Head, Tail> Result2;
};

template <typename Head, typename Tail, typename T>
struct PartitionH<TypeList<Head, Tail>, TypeList<T, NullType> >
{
    typedef NullType Result1;
    typedef TypeList<Head,Tail> Result2;
};

template <typename H1, typename T1, typename H2, typename T2>
struct PartitionH<TypeList<H1, T1>,TypeList<H2, T2> >
{
    typedef typename PartitionH<T1, typename T2::Tail>::Result1 R1;
    typedef TypeList<H1, R1> Result1;
    typedef typename PartitionH<T1, typename T2::Tail>::Result2 Result2;
};

template <typename TList>
struct Partition;

template <>
struct Partition<NullType>
{
    typedef NullType Result1;
    typedef NullType Result2;
};

template <typename T>
struct Partition<TypeList<T, NullType>>
{
    typedef NullType Result1;
    typedef TypeList<T, NullType> Result2;
};

template <typename TList>
struct Partition
{
    typedef typename PartitionH<TList, TList>::Result1 Result1;
    typedef typename PartitionH<TList, TList>::Result2 Result2;
};

Применение:

typedef Partition<TYPELIST_5(char, short, int, long, bool)>::Result1 typePart1;
typedef Partition<TYPELIST_5(char, short, int, long, bool)>::Result2 typePart2;

Список типов, полученный путем инвертирования первой половины списка типов.

Ну что, у нас уже есть Reverse, и у нас уже есть Partion. Несложно, правда?

template<typename TList>
struct ReverseOneHalf
{
    typedef TList Result;
};

template<typename Head, typename Tail>
struct ReverseOneHalf<TypeList<Head, Tail>>
{
    typedef typename Append<typename Reverse<typename Partition<TypeList<Head, Tail>>::Result1>::Result, typename Partition<TypeList<Head, Tail>>::Result2>::Result Result;
};

На самом деле должно было быть ещё 10 примеров, но простите, утомился. Их можно придумывать бесконечно, но думаю, написав штучек 20, вы точно поймёте всю суть!

Ну и скажу, что вместо if можно спокойно использовать конструкцию вида (OK) ? (A) : (B).

А теперь немножко отступления от списков типов, а просто ещё несколько примеров на вычисления при компиляции.

Считаем p^q. Cчитаем с конца, p^q = p * p^(q - 1).

template<int p, int q>
struct Power;

template<int p, int q>
struct Power<p, q> {
    enum { value = p * typename Power<p, q - 1>::value };
};

template<int p>
struct Power<p, 0> {
    enum { value = 1 };
};

Применение:

cout << "5^3 = " << Power<5, 3>::value << endl;
cout << "2^10 = " << Power<2, 10>::value << endl;
cout << "3^15 = " << Power<3, 15>::value << endl;

Возвращает значение 1, если второй список является подпоследовательностью первого, в противном случае возвращает значение 0.

Вот это тоже интересно! Код прилагается, а насчет подумать как работает, это вы сами.

template<typename TList1, typename TList2>
struct Subsequence;

template<>
struct Subsequence<NullType, NullType>
{
    enum { value = 1 };
};

template<typename TList>
struct Subsequence<TList, NullType>
{
    enum { value = 1 };
};

template<typename TList>
struct Subsequence<NullType, TList>
{
    enum { value = 0 };
};

template<typename H1, typename T1, typename T2>
struct Subsequence<TypeList<H1, T1>, TypeList<H1, T2>>
{
    enum { value = typename Subsequence<T1, T2>::value };
};

template<typename H1, typename T1, typename H2, typename T2>
struct Subsequence<TypeList<H1, T1>, TypeList<H2, T2>>
{
    enum { value = typename Subsequence<T1, TypeList<H2, T2>>::value };
};

Ну и домашнее задание, придумать, как найти пересечение двух списков!

Это то, что я прохожу по программированию на 2 курсе, в 1 семестре.

А вот и все исходники, их там гораздо больше, чем описано тут:

ListOfTypes Header File