Путаница в C ++

1 В чем разница между void DoSomething (const Foo & foo) и void DoSomething(Foo foo)? Если мы не укажем &, то экземпляр Foo будет передан по значению (а не по ссылке). Это будет то же самое, что и аргумент const + & in, за исключением отсутствия проверки во время компиляции. Итак, почему использование const + & становится лучшей практикой по сравнению с аргументом без & и const?

В C # объект передается по ссылке, но, похоже, этого нет в C ++.

Есть несколько отличий в порядке важности:

• Если объект Foo невозможно скопировать, нужно передать его по ссылке
• Если объект Foo является базовым классом, вы должны получить его по ссылке, чтобы пользователи могли вызывать ваши функции с производными классами.
• Значение фактического объекта может измениться, даже если у вас есть ссылка на него const.
• Эффективность, копирование типов пользователей может быть дорогостоящим, но компиляторы могут быть достаточно умными, чтобы понять это, так что ...

2 В книге, которую я читаю, сказано, что функции-члены передают неявный параметр по ссылке.

Может ли кто-нибудь дать мне образец неявного параметра и по ссылке? Я знаю, что если мы хотим передать объект по ссылке, нам нужно использовать & (например, Foo (Person & p)), но почему С ++ передает объект по ссылке для неявного параметра? Я читал, что неявный параметр в C ++ похож на Contructor (string str): strMemberVariable (str) {} ...

Под неявным параметром следует понимать this, то есть сам объект. Он эффективно передается по ссылке, поскольку вы можете изменить его состояние в функции-члене.

Следуя замечанию Konrad: обратите внимание, что сам this не передается по ссылке, this является ссылкой (указателем) на объект, а передается по значению. Вы не можете изменить адрес памяти вашего объекта как хотите;)

3 Является ли массив единственным, который передается по ссылке в C ++?

Это не так. Вы увидите изменения в элементах массива, но сам массив (структура) не изменится.

После замечания FredOverflow, иллюстрация:

void fun(int* p, size_t size);

int main(int argc, char* argv[])
{
  int array[15];
  fun(array, 15);
}

Мы не знаем, что делает fun, он, вероятно, изменит некоторые элементы array, но каким бы ни было его действие, array останется массивом из 15 целых чисел: содержимое изменяется, а структура - нет.

В результате для изменения array нам понадобится еще одно объявление:

void changer(int*& array, size_t& size);

Таким образом, мы можем изменить как содержимое, так и структуру (а также передать новый размер). И, конечно же, мы можем вызывать эту функцию только с массивом, который был размещен динамически.

4 Почему я не могу использовать Foo fInstance в классе Foo?

Потому что это бесконечная рекурсия. Подумайте об этом с точки зрения компилятора и попробуйте угадать размер Foo. Размер Foo - это сумма размеров его атрибутов, плюс, возможно, некоторая информация о заполнении и типе. Кроме того, размер объекта должен быть не менее 1, чтобы его можно было адресовать. Итак, если у Foo есть Foo, каков его размер :)?

Обычное решение - использовать умный указатель:

class Foo
{
public:

private:
  std::unique_ptr<Foo> mInstance;
};

Поскольку размер указателя не зависит от размера объекта, на который указывает, поэтому здесь не происходит рекурсия :)

Поскольку здесь так много заблуждений и совершенно ложных ответов, это моя попытка исправить это:

В чем разница между void DoSomething(const Foo& foo) и void DoSomething(Foo foo)?

Как говорили другие, второй код требует копии (обычно вызывая конструктор копирования Foo).

Итак, почему использование const + & становится лучшей практикой по сравнению с аргументом без & и const?

Есть несколько особых целей, на которые другие уже ответили (например, полиморфизм времени выполнения). Это не объясняет, почему это стало лучшей практикой. Причина этого проста и уродлива: потому что это величины более эффективно. Представьте, что вы передаете вектор или строку другому методу - или просто любую большую структуру данных. Стоимость копирования, как правило, будет огромной, и методы могут часто вызываться в коде - на самом деле, методы вызываются обычно очень часто, в противном случае код плохо спроектирован.

С другой стороны, когда вы передаете объект как const ссылку, это внутренне (обычно) реализуется через указатель. Указатели можно всегда эффективно копировать на всех архитектурах.

В книге, которую я читаю, сказано, что функции-члены передают неявный параметр по ссылке.

Я считаю, что книга неправильная. Функции-члены классов неявно передают указатель this, который ссылается на текущий объект. Однако это указатель, и C ++ запрещает его изменять. Нет причин, по которым он будет передаваться по ссылке.

Является ли массив единственным, что передается по ссылке в C ++?

В C ++ массивы передаются редко - обычно они передаются как указатели:

void foo(int[] x) { … }

на самом деле то же самое, что и

void foo(int* x) { … }

Компилятор считает эти два объявления одинаковыми. Когда вы пытаетесь вызвать любой из этих методов и передать ему массив x, C ++ неявно преобразует массив в указатель на его первый элемент - это называется «распад». Итак, foo(x) станет foo(&x[0]).

Однако массивы можно вместо этого передавать по ссылке, если указан их размер:

void foo(int (&x)[4]);

Но опять же, вы явно объявляете, что массив передается по ссылке.

В C # объект передается «по ссылке», но, похоже, этого нет в C ++.

Нет, это неправильно, это распространенное заблуждение. В таких языках, как C #, VB и Java, переменные всегда передаются по значению (исключение явно передается как ref в C # или ByRef в VB).

Отличие от C ++ в том, что переменные не содержат самого объекта класса, они содержат только ссылку. Таким образом, методу передается не сам объект, а только его ссылка (но это передается по значению).

Разница весьма существенная. Если C # использовал передачу по ссылке, следующий код распечатал бы другой результат:

void foo(string s) {
    s = "world";
}

string s = "hello";
foo(s);
Console.WriteLine(s); // prints "hello"

Почему я не могу использовать Foo fInstance в классе Foo?

Потому что концептуально объекту Foo потребуется бесконечное количество места. Технически тип Foo неполон в определении Foo.

Что вам, вероятно, нужно, так это указатель на Foo как на член.

Разница между void DoSomething(const Foo& foo) и void DoSomething(Foo foo) заключается в том, что первый передает параметр по ссылке, а второй - по значению. Практические отличия заключаются в следующем:

1. Эффективность. Передача по значению может потребовать вызова конструктора копирования. Если конструктор копирования стоит дорого, передача по значению приведет к дополнительным накладным расходам.
2. Применимость. Для передачи по значению требуется общедоступный конструктор копии. Если класс не поддерживает конструктор копирования, его нельзя передать по значению.
3. Семантика. При передаче по ссылке вы не знаете, на кого можно ссылаться. Если базовый объект изменяется по какой-либо другой причине, значение ссылки изменится.

Чтобы объяснить №3 немного лучше, рассмотрим следующую ситуацию:

std::string global_string;

void foo(const std::string &str)
{
    if (str.empty())
    {
        global_string = "whatever";
        // is str still empty??
    }
}

Если foo вызывается как foo(global_string), то при изменении global_string это также изменяетstr.

Один за раз:

1. doStuff(Foo f) означает, что новый Foo объект будет создан в стеке при вызове метода - AKA по значению. Вызов doStuff(const Foo &f) означает, что вы просто передаете новую ссылку, объект не дублируется, вы только держите ссылку на него. Это самый безопасный способ передачи аргументов, поскольку он не требует дублирования копии объекта. Это называется передачей по ссылке и является наиболее близким к поведению Java / C #.

2. О каком неявном параметре вы говорите?

3. Опять же, массивы (при условии, что они std::arrays) могут передаваться по значению, указателю или ссылке - единого поведения нет. Как упоминал Конард, массивы в стиле C (не более чем блоки памяти) не могут передаваться по значению.

Передача по константной ссылке, а не по значению - не совсем хорошая практика.

В этом сообщении блога объясняется, почему.

Люди склонны думать, что ссылка на константу выполняется быстрее, но правда в том, что компилятору разрешено оптимизировать копию при передаче по значению, поэтому передача по значению является хорошим вариантом по умолчанию (и действительно, стандартная библиотека обычно это делает. Например, , std::for_each принимает два итератора по значению и один функтор по значению)

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

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

Другой причиной передачи по ссылке (константной или иной) может быть использование полиморфных объектов. Допустим, у вас есть базовый класс B и производный класс D. Вы можете безопасно передать объект типа D как const B&, но передача его по значению в качестве объекта типа B может привести к разрезанию (копируется только подобъект B, а не весь объект D).

Поэтому хорошей практикой является передача по значению по умолчанию, но передача по константной ссылке определенно имеет свое место. Оба языка не зря.

  What is the differences between void DoSomething(const Foo& foo) and

void DoSomething (Foo foo)?

прагматически нет никакой разницы, константа не позволит вам изменить содержимое 'foo', тогда как передача по значению также не повлияет на содержимое аргумента, однако с точки зрения эффективности const Foo & foo более эффективна, поскольку она не будет создать копию при передаче объекта методу.

В книге, которую я читаю, сказано, что функции-члены передают неявный параметр по ссылке.

В книге говорится о неявном указателе this, который передается каждой нестатической функции-члену, определенной в классе. Это потому, что C ++ хранит копию каждой функции-члена в классе не в каждом объекте, поэтому метод должен знать, с каким объектом этого класса он должен работать.

class FOO{
 int x;
 void doSomthing(int x);
}

void FOO::doSomething(int x){
  x = x;
}

будет скомпилирован во что-то вроде этого

void FOO::doSomething(FOO* this, int x){
  this->x = x;
}

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

В чем разница между void DoSomething (const Foo & foo) и void DoSomething (Foo foo)?

Вообще говоря, последний будет глубоко скопировать передаваемый аргумент (другими словами, он сделает копию исходного объекта Foo). Первый сделает неглубокую копию переданного аргумента (копируя его адрес в неизменяемую константную ссылку, а не копируя фактический объект Foo).

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

Может ли кто-нибудь дать мне образец неявного параметра и по ссылке? Я знаю, что если мы хотим передать объект по ссылке, нам нужно использовать & (например, Foo (Person & p)), но почему С ++ передает объект по ссылке для неявного параметра? Я читал, что неявный параметр в C ++ похож на Contructor (string str): strMemberVariable (str) {} ...

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

class Foo
{
    Foo(int x) {...}
};

Это неявно. Это позволяет нам писать такой код:

Foo foo = 123;

void f(const Foo& x);
f(123);

Хотя это явно:

class Foo
{
    explicit Foo(int x) {...}
};

... а не предыдущий код. Соответствующим образом необходимо изменить предыдущий код:

Foo foo(123);

void f(const Foo& x);
f(Foo(123) );

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

Является ли массив единственным, что передается по ссылке в C ++?

Я не совсем уверен, о чем здесь спрашивают, но массивы нельзя передавать по значению, если вы это имеете в виду. Мы можем передавать только ссылки / указатели на массивы:

// takes an array of 10 integers
void fn(int(&some_array)[10]);

// takes a pointer to an int array
void fn(int* some_array);

// takes a pointer to an int array (the 10 
// literal constant is ignored) and this function
// can likewise take any pointer to int
void fn(int some_array[10]);

Почему я не могу использовать Foo fInstance в классе Foo?

Это бесконечно рекурсивно. Foo хранит fInstance, fInstance хранит другой fInstance и так далее. Нет ничего, что могло бы остановить рекурсию, поэтому у вас были бы просто объекты, хранящие объекты, хранящие объекты, хранящие объекты, и так далее, пока у вас не закончится память. Таким образом, компиляторы обнаруживают это условие и запрещают его, поскольку из него не может возникнуть законное поведение во время выполнения. Также не было бы способа определить размер Foo - это было бы бесконечное значение.

void DoSomething(Foo foo)

Фактически передает копию foo и

void DoSomething(Foo& foo)

Передает ссылку на foo, поэтому, если вы измените foo в своей функции, вы измените исходный foo. Я надеюсь в этом есть смысл.

Что касается массивов, массив на самом деле является указателем на начало массива, и этот указатель передается (весь массив не копируется).

array[5] = 0;//is the same as :
*(array+5) = 0; //this

В чем разница между void DoSomething (const Foo & foo) и void DoSomething (Foo foo)

DoSomething (Foo foo) передает объект foo по значению, если Foo является примитивным типом данных, но по ссылке, если Foo является пользовательским типом данных. Но во втором случае, если вы измените foo, он отразится обратно на исходный объект, что часто нежелательно. Об этом позаботится DoSomething (const Foo & foo), который передает foo по ссылке (таким образом, экономя дополнительные затраты памяти на передачу по значению) и по-прежнему не предоставляет доступ на запись в foo функции DoSomething. Таким образом, это лучшая практика.

Может ли кто-нибудь дать мне образец неявного параметра и по ссылке?

Примером неявного параметра в функциях-членах является ссылка на родительский объект, т.е. this, который никогда не упоминается в определении функции, но всегда доступен для использования.

Является ли массив единственным, что передается по ссылке в C ++?

Нет, все определенные пользователем объекты передаются по ссылке.