%> <td>....</td>
<%

S>Зато незнание языка много что значит У меня на собеседовании треть кандитатов уходила после того, как не могли ответить на один из первых вопросов

class test
{
public:
    test (char *a): m_ref(*a) {}

    char &m_ref;
};

class Test
{
public:
    Test(int i):m_i(i){}
private:
    int& m_i;
};

A>class Test
A>{
A>public:
A>    Test(int i):m_i(i){}
A>private:
A>    int& m_i;
A>};
A>

// CppLinks.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <conio.h>
#include <iostream>

using std::cout;
using std::cin;
using std::endl;

class C1
{
public:
    C1(int &ai): i(ai)
    {
    }


    int &i;
};

class C2
{
public:
    void PrintI()
    {
        cout << i << endl;
    }
    C1 * GetC1()
    {
        return c1;
    }
    C2(int ai)
    {
        i  = ai;
        c1 = new C1(i);
    }

    virtual ~C2()
    {
        delete c1;
        c1 = NULL;
    }

private:
    int i;
    C1 * c1;
};

int _tmain(int argc, _TCHAR* argv[])
{
    C2 c2(5);
    C1 * c1 = c2.GetC1();

    c2.PrintI();
    (*c1).i = 1;
    c2.PrintI();

    _getch();
    return 0;
}

void Foo::bar(int a = 4, int b)
{
}

class Foo
{
public:
    Foo(int j) { i=new int[j]; }
    ~Foo() { delete i; }
private:
    int* i;
};

class Bar: Foo
{
public:
    Bar(int j) { i=new char[j]; }
    ~Bar() { delete i; }
private:
    char* i;
};


void main()
{
    Foo* f=new Foo(100);
    Foo* b=new Bar(200);
    *f=*b;
    delete f;
    delete b;
}

> S>Вот это я понимаю, и коварно, и бессмысленно — потому что никто в здравом уме такого не напишет. Хуже вопрос только про ++i++ и скобки

>

class Foo
{
    void bar(int a, int b = 0);
};

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

struct ABC
{
     int &a;
};

int somefunc()
{
    struct ConnectGuard
    {
        Connection &c;
        ConnectGuard(Connection &c): c(c){}
        ~ConnectGuard(){ c.Close(); }
    }

    Connection c;
    if(c.Open(...))
    {
        ConnectGuard(c);
        ....
        if(...)
             return -1;
        ....
        if( ....)
             return -1;
        ....
    }
}

FDS>>Да можно и не надо

#include "stdafx.h"
#include <conio.h>
#include <iostream>

using std::cout;
using std::cin;
using std::endl;

class C1
{
public:
    C1(int &ai): i(&ai), li(ai) // указатель берётся от существующей переменной, ничего проверять на NULL не надо
    {
    }

    int * const i;  // указатель константен - его нельзя изменить
    int &li;        // абсолютно аналогично со ссылкой, её ведь тоже нельзя изменить во время работы
};

class C2
{
public:
    void PrintI()
    {
        cout << i << endl;
    }
    C1 * GetC1()
    {
        return c1;
    }
    C2(int ai)
    {
        i  = ai;
        c1 = new C1(i);
    }

    virtual ~C2()
    {
        delete c1;
        c1 = NULL;
    }

private:
    int i;
    C1 * c1;
};

int _tmain(int argc, _TCHAR* argv[])
{
    C2 c2(5);
    C1 * c1 = c2.GetC1();

        // как и в случае со ссылкой c1->li = 1;
        // всё проходит нормально, только мы явно показываем, что изменяем не переменную-поле класса,
        // а значение переменной, расположенной по некоторому адресу
    c2.PrintI();
    *c1->i = 1;      

        // Попытаемся обнулить указатель - не получится. Код полностью аналогичен коду со ссылкой за исключением напоминания программисту
        // что он работает не с переменной, а с указателем на переменную
//    c1->i  = NULL;    // Error    1    error C2166: l-value specifies const object    f:\prg\tmp\070530cpplinks\cpplinks\cpplinks.cpp    87    

    c2.PrintI();

    _getch();
    return 0;
}

_>struct ABC
_>{
_>     int &a;
_>};

_>

class Foo;
class A {
public:
    A(Foo&);
    A();
    void do_something();
private:
    Foo& m_foo;
    bool m_is_foo_ok;
}

A::A(Foo& foo)
: m_foo(foo)
, m_is_foo_ok(true)
{}

A::A(Foo& foo)
: m_foo(*NULL)
, m_is_foo_ok(false)
{}

void A::do_something()
{
    if (m_is_foo_ok){
        m_foo.do_something();
    } else {
        // TODO хм.. надо будет подумать как обрабатывать эту ситуёвину
    }
}

        ConnectGuard(c);

// примерная версия
int a1 = 0, b1=0;
int &a = a1, &b=b;

memcpy( &a, &b, sizeof(b) );

// прижелании можно использовать __asm
__asm lea, eax a

template <class Type>
class auto_ptr

Parameters
Type
The type of object for which storage is being allocated or deallocated.


The template class describes an object that stores a pointer to an allocated object myptr of type Type *.

FDS>Ну... мне нечего вспоминать на этот счёт — не знаю я этого

class Mutex
{

public:

   Mutex() { /* make mutex  here */ }
   ~Mutex() { /* destroy mutex  here */ }

   void lock();
   void unlock();
};


class CriticalSection
{

public:
   void lock();
   void unlock();
};

template<class Synch>
class ScopedLocker
{
    Synch  &m_synch;
   
public:
     ScopedLocker(Synch  &synch): m_synch(synch)
     {
        m_synch.lock();
     }

     ~ScopedLocker()
     {
        m_synch.unlock();
     }
};

typedef ScopedLocker<Mutex> MutextScopedLocker;

template<class Synch>
class ScopedLocker
{
    Synch * const m_synch;
   
public:
     ScopedLocker(Synch  &synch): m_synch(&synch)
     {
        m_synch->lock();
     }

     ~ScopedLocker()
     {
        m_synch->unlock();
     }
};

FDS>template<class Synch>
FDS>class ScopedLocker
FDS>{
FDS>    Synch * const m_synch;
   
FDS>public:

<skip>

FDS>

ScopedLocker<что-то> Locker(0); // будет компилиться

class ScopedLocker
{
 Synch * const m_synch;
....
public:
ScopedLocker(){}
};

ScopedLocker<что-то> Locker; // рухнет

C::C(const B *s) : x_(b)
{}

C::C(const B *s)
{
  x_.assign(s);
}

C::C()
{
   x = new K;
   y = new L;
}

C::~C()
{
   delete x;
   delete y;
}

S> Хуже вопрос только про ++i++ и скобки

S>class Foo
S>{
S>public:
S>    Foo(int j) { i=new int[j]; }
S>    ~Foo() { delete i; }
S>private:
S>    int* i;
S>};

S>class Bar: Foo
S>{
S>public:
S>    Bar(int j) { i=new char[j]; }
S>    ~Bar() { delete i; }
S>private:
S>    char* i;
S>};


S>void main()
S>{
S>    Foo* f=new Foo(100);
S>    Foo* b=new Bar(200);
S>    *f=*b;
S>    delete f;
S>    delete b;
S>}