_>#include <cstdio>

_>template<unsigned int i> struct factorial;
_>template<> struct factorial<0> { enum { value = 1 }; };
_>template<> struct factorial<1> { enum { value = 1 }; };
_>template<unsigned int i> struct factorial { enum { value = factorial<i - 1>::value * i }; };

_>int main()
_>{
_>        printf("10! = %d\n", factorial<10>::value);
_>        return 0;
_>}

S>Напишите компелябельный код для вызова чистовиртуальной функции

_D>char * str_reverse( char * str ) // все же лучше бы итераторы, на худой конец шаблон - вдруг wchar_t?
_D>{
_D>    char temp = 0; // зачем он здесь? место ему в блоке while
_D>    char * b = str, * e = str + strlen( str ) - 1; // по-хорошему всё же это бы в 2 строчки. А также std::strlen.

_D>    while( b <= e ) // зачем нестрогое неравенство? UB при нулевой длине!
_D>        //std::swap( *b++, *e-- ); // самый очевидный вариант для меня
        // можно еще показать знание ADL, написав using std::swap; swap(...);
_D>        //(*b++ = ( temp = *b, *e )), *e-- = temp; // за такое наверно можно и по шее схлопотать =)
_D>    {
_D>        temp = *b;
_D>        *b++ = *e;
_D>        *e-- = temp;
_D>    }

_D>    return str;
_D>}

_D>void test_str_reverse()
_D>{
_D>    char str[] = {"hello world !"}; // смысл { } ?

_D>    std::cout << str << std::endl;
_D>    std::cout << str_reverse( str ) << std::endl;
_D>}
_D>

_D>template < int size > // std::size_t
_D>void print_array( int (&array)[size], int print_size = size ) // std::copy, std::ostream_iterator?
_D>{
_D>    for( int ii = 0; ii < print_size; ++ii )
_D>        std::cout << array[ii] << " ";
_D>    std::cout << "\n";
_D>}

// ну здесь template и итераторы так и просятся...
_D>void arrays_intr( const int *ar1, const int *ar2, int *res, const int size, int *res_size ) // почему res_size не ссылка?
_D>{
_D>    const int *ar1_end = ar1 + size, *ar2_end = ar2 + size;

_D>    *res_size = 0;
_D>    while( ar1 < ar1_end && ar2 < ar2_end ) // привыкай к !=
_D>    {
_D>        if ( *ar1 == *ar2 ) // тебе не обещали EqualityComparable (ты же ведь добавишь template и расширишь функцию для всевозможных типов, не так ли?)
_D>        {
_D>            if ( (*res_size) == 0 || *(res - 1) != *ar1 ) // Эта строчка вообще лишняя. "abbbbccdff" * "aabbccdef" = "abbccdf".
               // Эквивалентных элементов брать по минимуму из двух последовательностей.
_D>            {
_D>                *res++ = *ar1;
_D>                ++(*res_size);
_D>            }
_D>            ++ar1;
_D>            ++ar2;
_D>        }
_D>        else
_D>        {
_D>            *ar1 > *ar2 ? ++ar2 : ++ar1; // и operator > тоже не обязан присутствовать
_D>        }
_D>    }
_D>}

_D>void test_arrays()
_D>{
_D>    int ar1[] = { 1, 2, 3, 5, 5, 71 };
_D>    int ar2[] = { 0, 1, 2, 3, 4, 5 };
_D>    const int size = sizeof( ar1 ) / sizeof( ar1[0] ); // поищи на кывте ARRAY_LENGTH и удиви интервьеров :)
_D>    int res_intr[ size ] = {0};
_D>    int res_size = 0;

_D>    print_array( ar1 );
_D>    print_array( ar2 );
_D>    arrays_intr( ar1, ar2, res_intr, size, &res_size );
_D>    print_array( res_intr, res_size );
_D>}
_D>

_>#include <cstdio>

_>template<unsigned int i> struct factorial;
_>template<> struct factorial<0> { enum { value = 1 }; };
_>template<> struct factorial<1> { enum { value = 1 }; };
_>template<unsigned int i> struct factorial { enum { value = factorial<i - 1>::value * i }; };

_>int main()
_>{
_>        printf("10! = %d\n", factorial<10>::value);
_>        return 0;
_>}
_>

U>>An auto_ptr is a pointer that serves as owner of the object to which it refers (if any). As a result, an object gets destroyed automatically when its auto_ptr gets destroyed. A requirement of an auto_ptr is that its object has only one owner.