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 MyString::addChar(char ch) {
    if (charsNum < buffSize) {
        buff[charsNum++] = ch;
        return;
    } 

    char* temp = new char[buffSize+1];
    buffSize = buffSize + 1;
    for(int i = 0; i < charsNum; i++) temp[i] = buff[i];
    temp[charsNum++] = ch;
    delete buff;
    buff = temp;
    delete temp;

    return;    
}

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

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

_>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 хм.. надо будет подумать как обрабатывать эту ситуёвину
    }
}

An ancient joke about C++ was that the language is called C++ and not ++C because the language is improved (incremented), but many people still use it as C (the previous value). Fortunately, the joke is now obsolete, but it's a helpful illustration for understanding the difference between the two operator forms.

This is not premature optimization; it is avoiding premature pessimization.

T T::operator++(int)
{
  T tmp(*this);
  ++*this;
  return tmp;
}

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>}

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; // рухнет

FDS>>>>Хм, программисту он должен. Я вот сейчас даже проверил — в VS 2005 генерирует

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

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


struct CCC
{
    int &b;
    int  &c;
    CCC(int &a, int &d): b(a), c(d)
    {
    }
};

struct ABC
{
    public:
        int &a;
};

int _tmain(int argc, _TCHAR* argv[])
{
    int k = 2; int c = 0;
    CCC d(k, c);
    ABC * D = (ABC *) &d;
    ABC A(*D);

    cout << A.a << endl;
    k = 22;
    cout << A.a << endl;

    _getch();
    return 0;
}

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;
        ....
    }
}

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

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

struct ABC
{
     int &a;
};

        ConnectGuard(c);

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

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

F>Я раньше тоже всегда писал i++, казалось красивее. Почитав про копирование перешел на ++i без каких-то проблем — теперь так же кажется красивее это. Или у тебя есть строгое доказательство большей красивости постфикса над префиксом?

iterator i = start;
while( i != end)
{
  // ....
  ++i;
}

int i      = 0;
int kjfdsl = 0;

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

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

    char &m_ref;
};

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);
};

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