Должен ли я использовать указатели для полей моего класса C ++?

Ответ на вопрос 1:

Однако кажется, что это невозможно, потому что они [ссылки] не могут быть объявлены неинициализированными (верно?).

Правильно.

Ответ на вопрос 2:

В моем фрагменте bar1 автоматически создается с помощью конструктора по умолчанию (это не то, что я хочу), & bar2 вызывает ошибку компилятора, потому что вы не можете использовать неинициализированные ссылки (правильно?),

Вы инициализируете ссылки вашего класса в списке инициализаторов вашего конструктора:

class Foo
{
public:
    Foo(Bar &rBar) : bar2(rBar), bar3(NULL)
    {
    }

    Bar bar1;
    Bar &bar2;
    Bar *bar3;
}

Ответ на вопрос 3:

В конкретном сценарии, над которым я сейчас работаю, я не хочу использовать обычные переменные (кстати, какой для них правильный термин?)

Для них нет правильного названия, обычно вы можете просто назвать указатели для большинства обсуждений (кроме этого), и все, что вам нужно обсудить, также применимо к ссылкам. Вы инициализируете элементы без указателей и ссылок таким же образом через список инициализаторов.

class Foo
{
public: 
  Foo()  : x(0), y(4)
  {
  }

  int x, y;
};

Ответ на вопрос 4:

указатели могут быть объявлены неинициализированными (кстати, лучше ли установить это значение в NULL?).

Их можно объявить неинициализированными да. Лучше инициализировать их значением NULL, потому что тогда вы можете проверить, действительны ли они.

int *p = NULL;
//...

//Later in code
if(p)
{
  //Do something with p
}

Ответ на вопрос 5:

Похоже, в этом сценарии мне нужно использовать указатели, это правда? Кроме того, как лучше всего использовать переменную?

Вы можете использовать указатели или ссылки, но ссылки не могут быть повторно назначены, и ссылки не могут быть NULL. Указатель похож на любую другую переменную, например int, но содержит адрес памяти. Массив - это псевдоним для другой переменной.

Указатель имеет свой собственный адрес в памяти, тогда как массив следует рассматривать как разделяющий адрес переменной, на которую он ссылается.

Со ссылкой после ее инициализации и объявления вы используете ее так же, как если бы вы использовали переменную, на которую она ссылается. Особого синтаксиса нет.

С указателем, чтобы получить доступ к значению по адресу, который он содержит, вы должны dereference указатель. Вы делаете это, помещая перед ним *.

int x=0;
int *p = &x;//p holds the address of x
int &r(x);//r is a reference to x
//From this point *p == r == x
*p = 3;//change x to 3
r = 4;//change x to 4
//Up until now
int y=0;
p = &y;//p now holds the address of y instead.

Ответ на вопрос 6:

А как насчет умных указателей и т. Д.? Это актуально?

Интеллектуальные указатели (см. Boost :: shared_ptr) используются, чтобы при выделении памяти в куче не нужно было вручную освобождать память. Ни один из приведенных выше примеров не размещен в куче. Вот пример, когда использование умных указателей могло бы помочь.

void createANewFooAndCallOneOfItsMethods(Bar &bar)
{
    Foo *p = new Foo(bar);  
    p->f();
    //The memory for p is never freed here, but if you would have used a smart pointer then it would have been freed here.  
}

Ответ на вопрос 7:

Обновление 1:

Почему после попытки реализовать поле ссылочной переменной в моем классе и его инициализации в конструкторе может появиться следующая ошибка?

Проблема в том, что вы не указали список инициализаторов. См. Мой ответ на вопрос 2 выше. Все после двоеточия:

class VTexture
{
public:
    VTexture(vimrid::imaging::ImageMatrix &rImage)
      : image(rImage)
    { 
    }
private:
    vimrid::imaging::ImageMatrix ℑ
}

Их можно инициализировать. Вам просто нужно использовать список инициализаторов членов.

Foo::Foo(...) : bar1(...), bar2(...), bar3(...)
{
  // Whatever
}

Таким образом рекомендуется инициализировать все ваши переменные-члены. В противном случае, для типов, отличных от примитивных, C ++ все равно инициализирует их конструктором по умолчанию. Назначение их в фигурных скобках фактически их переназначает, а не инициализирует.

Также имейте в виду, что список инициализаторов элементов указывает КАК инициализировать переменные-члены, а НЕ ПОРЯДОК. Члены инициализируются в том порядке, в котором они объявлены, а не в порядке инициализаторов.

Используйте шаблон проектирования нулевого объекта

Я использую ints, но он будет одинаковым для любого типа.

//header file
class Foo
{
public:
   Foo( void );
   Foo( int& i );
private:
   int& m_int;
};

//source file
static int s_null_Foo_m_i;

Foo::Foo( void ) :
   m_i(s_null_Foo_m_i)
{ }

Foo::Foo( int& i ) :
   m_i(i)
{ }

Теперь вы должны убедиться, что Foo имеет смысл при построении по умолчанию. Вы даже можете определить, когда Foo был сконструирован по умолчанию.

bool Foo::default_constructed( void )
{
   return &m_i == &s_null_Foo_m_i;
}

Я полностью согласен с мнением: всегда предпочитаю ссылки указателям. Есть два примечательных случая, когда вам не обойтись без референтного члена:

1. Null имеет значимое значение.

   Этого можно избежать с помощью шаблона проектирования нулевого объекта.

2. Класс должен быть назначаемым.

   Компилятор не будет генерировать оператор присваивания для классов, имеющих ссылочный член. Вы можете определить его самостоятельно, но вы не сможете изменить место привязки ссылки.

Существует также побочный эффект, когда вы определяете, когда вы определяете Bar и Bar *

class Foo
{
public:
    Bar bar1; // Here, you create a dependency on the definition of Bar, so the header //file for bar always needs to be included.
    Bar &bar2;
    Bar *bar3; //Here, you create a pointer, and a forward declaration is enough, you don't have to always include the header files for Bar , which is preferred.
}

Использование ссылок только потому, что синтаксис -> громоздок, не лучшая причина ... Ссылки имеют одно большое преимущество перед указателями в том, что значения NULL невозможны без обмана, но также имеют недостатки в инициализации и риск случайного незаконного связывания временные, которые затем выходят за рамки (например, после неявного преобразования).

Да, интеллектуальные указатели, такие как повышающие, почти всегда являются правильным решением для обработки составных элементов, а иногда и для связанных элементов (shared_ptr).

class Foo {
public:
    Bar bar1;
    Bar &bar2;
    Bar *bar3;

    // member bar2 must have an initializer in the constructor
    Bar::Bar(Bar& _bar2) : bar1(), bar2(_bar2), bar3(new Bar()) {}

    Bar::~Bar() {delete bar3;}
}

Обратите внимание, что bar2 не просто инициализируется в ctor; он инициализируется объектом bar, который передается в качестве ссылочного параметра. Этот объект и поле bar2 будут связаны вместе на время жизни нового объекта Foo. Обычно это очень плохая идея, потому что трудно гарантировать, что время жизни двух объектов будет хорошо скоординировано (т. Е. Что вы никогда не избавитесь от переданного объекта bar до удаления объекта Foo).

Вот почему очень предпочтительно использовать либо переменные экземпляра (как в bar1), либо указатели на объекты, размещенные в куче (как в bar3.)