_>#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;
_>}
_>

_>class B;

_>class A {
_>public:
_>  void SomethingHappen() { b_.DoSomething(); }
_>private:
_>  B &b_;
_>};

_>class B {
_>public:
_>  void DoSomething();
_>};
_>

_>#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;
_>}
_>

_>>class B;

_>>class A {
_>>public:
_>>  void SomethingHappen() { b_.DoSomething(); }
_>>private:
_>>  B &b_;
_>>};

_>>class B {
_>>public:
_>>  void DoSomething();
_>>};
_>>

А>unsigned int var = 5;
А>unsigned int fact5 = factorial<var>::value;
А>

C>void f() throw() {
C>   throw 1;
C>}
C>

КР>int i(0);
КР>

А>unsigned int res = factorial<13>::value;
А>

А>warning C4307: '*' : integral constant overflow

C>void f() throw()
C>{
C>  throw 1;
C>}
C>

S>15.4/8
S>Whenever an exception is thrown and the search for a handler (15.3) encounters the outermost block of a
S>function with an exception-specification, the function unexpected() is called (15.5.2) if the exceptionspecification
S>does not allow the exception.[Example:
S>class X { };
S>class Y { };
S>class Z: public X { };
S>class W { };
S>void f() throw (X, Y)
S>{
S>int n = 0;
S>if (n) throw X(); // OK
S>if (n) throw Z(); // also OK
S>throw W(); // will call unexpected()
S>}
S>—end example]


S>15.4/9
S>The function unexpected() may throw an exception that will satisfy the exception-specification for
S>which it was invoked, and in this case the search for another handler will continue at the call of the function
S>with this exception-specification (see 15.5.2), or it may call terminate().

S>15.4/11
S>A function with no exception-specification allows all exceptions. A function with an empty exceptionspecification,
S>throw(), does not allow any exceptions.

S>15.5.1 The terminate() function
S>...

S>15.5.2 The unexpected() function
S>...

_DA>23.2.5 Class vector<bool>
_DA>To optimize space allocation, a specialization of vector for bool elements is provided:
_DA>...

_DA>>23.2.5 Class vector<bool>
_DA>>To optimize space allocation, a specialization of vector for bool elements is provided:
_DA>>...

_>sh@venus:~/tmp/cpp> cat main.cpp
_>#include <iostream>
_>using namespace std;

_>class ABC
_>{
_>public:
_>virtual void func() = 0 { cout << "I'm Pure Virtual" << endl;};
_>};

_>class BCD : public ABC
_>{
_>public:
_>virtual void func() { cout << "I'm not Pure Virtual" << endl;};
_>void func2() {ABC::func();};
_>};

_>int main(int argc, char* argv[])
_>{
_>BCD b;
_>b.func2();
_>}
_>sh@venus:~/tmp/cpp> g++ main.cpp
_>main.cpp:7: error: pure-specifier on function-definition
_>

_>>sh@venus:~/tmp/cpp> cat main.cpp
_>>#include <iostream>
_>>using namespace std;

_>>class ABC
_>>{
_>>public:
_>>virtual void func() = 0 { cout << "I'm Pure Virtual" << endl;};
_>>};

_>>class BCD : public ABC
_>>{
_>>public:
_>>virtual void func() { cout << "I'm not Pure Virtual" << endl;};
_>>void func2() {ABC::func();};
_>>};

_>>int main(int argc, char* argv[])
_>>{
_>>BCD b;
_>>b.func2();
_>>}
_>>sh@venus:~/tmp/cpp> g++ main.cpp
_>>main.cpp:7: error: pure-specifier on function-definition
_>>

S>>15.4/8
S>>Whenever an exception is thrown and the search for a handler (15.3) encounters the outermost block of a
S>>function with an exception-specification, the function unexpected() is called (15.5.2) if the exceptionspecification
S>>does not allow the exception.[Example:
S>>class X { };
S>>class Y { };
S>>class Z: public X { };
S>>class W { };
S>>void f() throw (X, Y)
S>>{
S>>int n = 0;
S>>if (n) throw X(); // OK
S>>if (n) throw Z(); // also OK
S>>throw W(); // will call unexpected()
S>>}
S>>—end example]


S>>15.4/9
S>>The function unexpected() may throw an exception that will satisfy the exception-specification for
S>>which it was invoked, and in this case the search for another handler will continue at the call of the function
S>>with this exception-specification (see 15.5.2), or it may call terminate().

S>>15.4/11
S>>A function with no exception-specification allows all exceptions. A function with an empty exceptionspecification,
S>>throw(), does not allow any exceptions.

S>>15.5.1 The terminate() function
S>>...

S>>15.5.2 The unexpected() function
S>>...

S>>>15.4/8
S>>>Whenever an exception is thrown and the search for a handler (15.3) encounters the outermost block of a
S>>>function with an exception-specification, the function unexpected() is called (15.5.2) if the exceptionspecification
S>>>does not allow the exception.[Example:
S>>>class X { };
S>>>class Y { };
S>>>class Z: public X { };
S>>>class W { };
S>>>void f() throw (X, Y)
S>>>{
S>>>int n = 0;
S>>>if (n) throw X(); // OK
S>>>if (n) throw Z(); // also OK
S>>>throw W(); // will call unexpected()
S>>>}
S>>>—end example]


S>>>15.4/9
S>>>The function unexpected() may throw an exception that will satisfy the exception-specification for
S>>>which it was invoked, and in this case the search for another handler will continue at the call of the function
S>>>with this exception-specification (see 15.5.2), or it may call terminate().

S>>>15.4/11
S>>>A function with no exception-specification allows all exceptions. A function with an empty exceptionspecification,
S>>>throw(), does not allow any exceptions.

S>>>15.5.1 The terminate() function
S>>>...

S>>>15.5.2 The unexpected() function
S>>>...

_DA>>>23.2.5 Class vector<bool>
_DA>>>To optimize space allocation, a specialization of vector for bool elements is provided:
_DA>>>...

_DA>я знаю что такое auto_ptr но видь он запрещен стандартом (и правильно)

S>>>>15.4/8
S>>>>Whenever an exception is thrown and the search for a handler (15.3) encounters the outermost block of a
S>>>>function with an exception-specification, the function unexpected() is called (15.5.2) if the exceptionspecification
S>>>>does not allow the exception.[Example:
S>>>>class X { };
S>>>>class Y { };
S>>>>class Z: public X { };
S>>>>class W { };
S>>>>void f() throw (X, Y)
S>>>>{
S>>>>int n = 0;
S>>>>if (n) throw X(); // OK
S>>>>if (n) throw Z(); // also OK
S>>>>throw W(); // will call unexpected()
S>>>>}
S>>>>—end example]


S>>>>15.4/9
S>>>>The function unexpected() may throw an exception that will satisfy the exception-specification for
S>>>>which it was invoked, and in this case the search for another handler will continue at the call of the function
S>>>>with this exception-specification (see 15.5.2), or it may call terminate().

S>>>>15.4/11
S>>>>A function with no exception-specification allows all exceptions. A function with an empty exceptionspecification,
S>>>>throw(), does not allow any exceptions.

S>>>>15.5.1 The terminate() function
S>>>>...

S>>>>15.5.2 The unexpected() function
S>>>>...

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.

E>23.2.4 Class template vector                                                                          [lib.vector]
E>1 A vector is a kind of sequence that supports random access iterators. In addition, it supports (amortized) constant time
E>insert and erase operations at the end; insert and erase in the middle take linear time. Storage management is handled
E>automatically, though hints can be given to improve efficiency. The elements of a vector are stored contiguously,
E>meaning that if v is a vector<T, Allocator> where T is some type other than bool, then it obeys the identity &v[n]
E>== &v[0] + n for all 0 <= n < v.size().
E>

_>#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;
_>}
_>