Константная ссылка-обертка

1. Член obj имеет тип Object*, но конструктор принимает ссылку. Следовательно, чтобы получить указатель, необходимо применить оператор адреса &. И член является указателем, потому что он может быть NULL (устанавливается в конструкторе по умолчанию), а ссылки никогда не могут быть NULL.

2. Частный член не является ссылкой на константу, а указатель на константу. Разыменовывается для получения ссылки.

3. В данном конкретном случае я также не вижу никакого негативного эффекта потенциального неявного преобразования.

1) &x в obj(&x) используется как оператор адреса.

2) Нет, это указатель. Его время Object *, а не Object &.

3) Чтобы предотвратить приведение несовместимых типов указателей, которые могут иметь свой собственный оператор приведения типов.

C++ имеет три разновидности null:

• NULL - устарело; используйте его только для проверки возвращаемых значений функций C, которые возвращают указатели
• 0 - устарело; буквальный ноль определен в стандарте как нулевой указатель
• nullptr — начиная с C++11, это предпочтительный способ проверки на нуль. Кроме того, nullptr_t является типобезопасным нулем.

1) Токен & имеет три значения:

• Унарный оператор адреса: берет адрес любого выражения lvalue, давая указатель на этот объект.
• Ссылочный знак: в объявлении означает ссылочный тип.
• Двоичный побитовый оператор И - здесь не используется

Поэтому важно знать, смотрите ли вы на объявление или на выражение.

explicit Cref( const Object & x )

Здесь символ появляется в объявлении параметра функции, что означает, что тип параметра x является ссылкой на Object, который равен const.

: obj ( &x ) {}

Здесь оператор используется в выражении инициализатора члена. Элемент obj инициализируется как указатель на x.

2) Поскольку элемент obj на самом деле является указателем, для получения ссылки необходим унарный оператор разыменования *.

3) В общем, рекомендуется использовать explicit в любом (не копируемом) конструкторе, который может принимать только один аргумент. К сожалению, язык по умолчанию не является явным и заставляет вас вместо этого использовать какое-то «неявное» ключевое слово, когда вы хотите. В этом случае вот одна довольно плохая вещь, которая могла бы случиться, если бы конструктор был неявным:

Object create_obj();
void setup_ref(Cref& ref) {
    ref = create_obj();
}

Никаких ошибок или предупреждений компилятора, но эта функция setup_ref хранит указатель на временный объект, который недействителен к моменту возврата из функции!

1) Тип obj не является ссылкой, obj является указателем, а константный указатель должен быть инициализирован адресом, поэтому должен применяться оператор адреса &. 2) Ссылка, которую возвращает метод get(), не является ссылкой на obj-член класса, а является ссылкой на объект, на который указывает obj, поэтому вам нужно использовать *, чтобы уважать его. 3) Ключевое слово "явно" означает, что мы отклоняем неявные преобразования, т. е. мы сообщаем компилятору, что не нужно делать за нас неявные преобразования с помощью этого конструктора.
Пример:

class Cref<Object> A;
Object B;
A=B;

Это нормально без явного — поскольку нам нужен объект Cref с правой стороны, компилятор автоматизирует создание объекта Cref с помощью конструктора Cref( const Object & B ). Но если вы добавите явное, компилятор не будет делать преобразования, будет ошибка компиляции.