class C
{
public:
  C /* no const */ * operator& () /* no const */ { return this; }
};

main()
{
  &(C()); // OK
}

 К> class C
 К> {
 К> public:
 К>   C /* no const */ * operator& () /* no const */ { return this; }
 К> };

 К> int main()
 К> {
 К>   &(C()); // OK
 К> }
 К>

int main()
{
  typedef const C CC;
  &CC(); // ERROR
}

class C
{
public:
  void f() { }
};

int main()
{
  C().f(); // OK
  return 0;
}

class C
{
public:
  C* operator& () { return this; }
};

&C();

C().operator&();

struct RValue
{
  void modify();
  void test() const;
};

void modify(RValue& v) { v.modify(); }
void test(RValue const& v) { v.test(); }

void main()
{
  RValue().modify(); // можно
  RValue().test();

  modify(RValue()); // низзя!
  test(RValue());
}

К>struct RValue
К>{
К>  void modify();
К>  void test() const;
К>};

К>void modify(RValue& v) { v.modify(); }
К>void test(RValue const& v) { v.test(); }

К>void main()
К>{
К>  RValue().modify(); // можно
К>  RValue().test();

К>  modify(RValue()); // низзя!
К>  test(RValue());
К>}
К>

К>Смысл где?

Disallowing conversions for nonconst reference arguments (§5.5) avoids the possibility of silly mistakes arising from the introduction of temporaries. For example:

void update(float& i) ;

void g(double d, float r)
{
update(2.0f) ; / / error: const argument
update(r) ; / / pass ref to r
update(d) ; / / error: type conversion required
}

Had these calls been allowed, update() would quietly have updated temporaries that immediately
were deleted. Usually, that would come as an unpleasant surprise to the programmer.

class RValue // глупость какая-то...
{
    static RValue* single_;
    RValue* aggregate_;
public:
    RValue(int indirection) { aggregate_ = (indirection<=0) ? this : new RValue(indirection-1); }
    ~RValue() { if(this != aggregate_) delete aggregate_; }

    RValue* somePtr() { return aggregate_; }
    RValue* anotherPtr() { return this; }
    RValue* thirdPtr() { return single_; }
    
    RValue* operator&() { в зависимости от смысла, выполняет somePtr|anotherPtr|thirdPtr (); }
};

struct ISome
{
    STDMETHOD(getManyObjects)(/*out*/ IAnother** ppA, /*out*/ IThird** ppB);
};

...
CComPtr<IAnother> pA;
pSome->getManyObjects( &pA, &CComPtr<IThird>() );    // & - указатель на член IXXX* m_ptr
...

template<class T> T* addressof(T& var)
{
    return reinterpret_cast<T*>(&reinterpret_cast<char&>(var));
}

/////////////////////////////////////////////////////
// пример

class Hide
{
public:
    virtual ~Hide() {}    // чтобы какое-нибудь содержание было (vfptr в данном случае)

    // для отладки функции addressof
    Hide* self() { return this; }
    Hide const* self() const { return this; }
private:
    // А пофиг, какой возвращаемый тип. Все одно private...
    void operator& () {}
    void operator& () const {}
};

int main()
{
    Hide h;
    Hide* ph1 = &h;    // здесь будет ошибка.
    Hide* ph2 = addressof(h);
    assert(ph2 == h.self());
}

++i;

operator ++(i);

int j;
j = ++i;

class C
{
public:
  C(const C&);
};

void f(C t);

int main()
{
  C c;
  f(c);
}

C t = c;

C c;
foo() ? C() : c;

ПК>C c;
ПК>foo() ? C() : c;
ПК>

static_cast<C>(c);

/* main.cpp */ 

/* main() */ 

#include <iostream> 

using namespace std;

int main()
 {
  int x=100;
  /*short*/ int y=20;
  
  ((x<y)?x:y)=1000;
  
  cout << "x=" << x << " y=" << y << endl ;
 
  return 0;
 }

В частности, результат вызова функций, возвращающих объекты не по ссылке;

#include <iostream> 

struct C
{
  C(int i) : i(i) { }

  int i;
};

bool operator <(const C& c, int i) { return c.i < i; }

std::ostream& operator <<(std::ostream& os, const C& c) { return os << c.i; }

int main()
{
  C x (100);
  int y = 20;
  ((x<y)?x:y)=1000;
  std::cout << "x=" << x << " y=" << y << std::endl;
}

x=100 y=20

ПК>Ну, имхо, это вопрос теологический

int x=1;

int &y=x;

The obvious implementation of a reference is as a (constant) pointer that is dereferenced each time it is used. It doesn’t do much harm thinking about references that way, as long as one remembers that a reference isn’t an object that can be manipulated the way a pointer is:

<картинка>

In some cases, the compiler can optimize away a reference so that there is no object representing that reference at runtime.

/* main.cpp */ 

/* main() */ 

#include <iostream> 
#include <typeinfo>

using namespace std;

template <class T>
struct IsReference
 {
  static const bool Value=false;
 };

template <class T>
struct IsReference<T &>
 {
  static const bool Value=true;
 };
 
template <class T> 
void test(T)
 {
  cout << "IsReference<T>::Value=" << IsReference<T>::Value << endl ;
 }
 
int main()
 {
  int x=0;
 
  test<int>(x);
  test<int &>(x);
 
  return 0;
 }

template <class T> 
void test(T х)
 {
  cout << "IsReference<T>::Value=" << IsReference<T>::Value << endl ;
  
  cout << "IsReference<T>::Value=" << IsReference<typeof (x)>::Value << endl ;
 }

ПК>>Ну, имхо, это вопрос теологический

A reference is an alternative name for an object.

Ш>. . .
Ш>

Ш>. . .
Ш>

int main()
{
    int i;

    ++i;        // well-defined behavior
    i = i + 1;  // undefined behavior
}

А>>int main()
А>>{
А>>    int i;

А>>    ++i;        // well-defined behavior
А>>    i = i + 1;  // undefined behavior
А>>}

Полезно понимать, что объект это нечто, имеющее четко определенные границы,
но этого недостаточно, чтобы отделить один объект от другого или дать оценку
качества абстракции. На основе имеющегося опыта можно дать следующее
определение:

Объект обладает состоянием, поведением и идентичностью; структура и поведение
схожих объектов определяет общий для них класс; термины "экземпляр класса" и
"объект" взаимозаменяемы.

...

Идентичность

Семантика. Хошафян и Коуплэнд предложили следующее определение:

"Идентичность — это такое свойство объекта, которое отличает его от всех
других объектов".

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

 А>>> int main()
 А>>> {
 А>>>    int i;

 А>>>    ++i;        // well-defined behavior
 А>>>    i = i + 1;  // undefined behavior
 А>>> }
 >

++i;

i += 1;

i = i + 1;

ПК>++i;

int f()
{
  int i = 10;
  return i;
}

int f(int& r)
{
  return r;
}

template< class T >
class vector
{
    const void * BASE = 0xffffffff;
    T    &operator[]( size_t n )
    {
        LockMemory();
        return *(T*)(BASE + n * sizeof( T ));
    }
};

int i;
int &a = i;

Ш>>Ну, вообще-то на этапе выполнения ничего, кроме сигналов на линиях нет. 0,1,фронт. Между прочим, разглядывая сигналы на ножках процессора на экране осцилографа или логического анализатора, начинаешь задумываться о сущности бытия. Все эти объекты, ссылки и прочее на самом деле суть абстрактные понятия, существующие только в голове. Их даже в тексте программы нет. Это мы, читая текст придаём ему смысл. (с) Ещё один Copyright (c) мой.

inline void swap(int &a,int &b)
 {
  int temp=a;
  
  a=b;
  
  b=temp;
 }

PUBLIC    ?swap@@YAXAAH0@Z                ; swap
; Function compile flags: /Ogty
; File c:\ss_root\c++\projects\test\main.cpp
;    COMDAT ?swap@@YAXAAH0@Z
_TEXT    SEGMENT
_a$ = 8                            ; size = 4
_b$ = 12                        ; size = 4
?swap@@YAXAAH0@Z PROC NEAR                ; swap, COMDAT

; 10   :   int temp=a;
; 11   :   
; 12   :   a=b;

    mov    edx, DWORD PTR _b$[esp-4] // вот здесь лежит ссылка b
    mov    eax, DWORD PTR _a$[esp-4] // а вот ссылка a
    mov    ecx, DWORD PTR [eax]      // вот мы загрузили в регистр значение целой переменной, на которую ссылалась ссылка a
    push    esi
    mov    esi, DWORD PTR [edx]
    mov    DWORD PTR [eax], esi

; 13   :   
; 14   :   b=temp;

    mov    DWORD PTR [edx], ecx
    pop    esi

; 15   :  }

    ret    0
?swap@@YAXAAH0@Z ENDP                    ; swap
_TEXT    ENDS

int a;
int &i = a;

 РМ> int i;
 РМ> int &a = i;
 РМ>

int f()
{
  int i = 10;
  return i;
}