Смотрю чужой код...
Не пойму одну вещ какой смысл объявлять передачу по ссылке в ф-ции для переменных интегральных типов и выведенных из них (typedef), то же вопрос касается передачи по константному указателю (не принимая во внимания того что можно сделать const_cast).
Компилятор как то особо обрабатывает такие объявления?

Здравствуйте, nen777w, Вы писали:

N>Смотрю чужой код...
N>Не пойму одну вещ какой смысл объявлять передачу по ссылке в ф-ции для переменных интегральных типов и выведенных из них (typedef), то же вопрос касается передачи по константному указателю (не принимая во внимания того что можно сделать const_cast).
N>Компилятор как то особо обрабатывает такие объявления?

а что собенного в том, что интегральные типы передаются по ссылке? Может быть ты имел ввиду const&? По поводу const*. Это похоже на опциональный аргумент. Можно и NULL передать.

Здравствуйте, Константин Л., Вы писали:

КЛ>а что собенного в том, что интегральные типы передаются по ссылке?

Тратиться дополнительное время на один уровень косвенности, а памяти отъедает меньше чем фактический тип только в случае long long;

КЛ>а что собенного в том, что интегральные типы передаются по ссылке? Может быть ты имел ввиду const&?
Да. Именно так, забыл указать. Если учеть то что кастов никаких с этой переменной в этом коде не проделывают.

КЛ>По поводу const*. Это похоже на опциональный аргумент. Можно и NULL передать.
Да, как то я об этом не подумал, просто сбило то что реально в коде этой ф-ции не допускают её работу с NULL.

Здравствуйте, np9mi7, Вы писали:

КЛ>>а что собенного в том, что интегральные типы передаются по ссылке?

N>Тратиться дополнительное время на один уровень косвенности, а памяти отъедает меньше чем фактический тип только в случае long long;

какие нибудь цифры, поддверждающие предположение имеются?

Здравствуйте, np9mi7, Вы писали:

N>Здравствуйте, Константин Л., Вы писали:

КЛ>>а что собенного в том, что интегральные типы передаются по ссылке?

N>Тратиться дополнительное время на один уровень косвенности, а памяти отъедает меньше чем фактический тип только в случае long long;

это ты о чем?

Здравствуйте, nen777w, Вы писали:

КЛ>>а что собенного в том, что интегральные типы передаются по ссылке? Может быть ты имел ввиду const&?
N>Да. Именно так, забыл указать. Если учеть то что кастов никаких с этой переменной в этом коде не проделывают.

лишняя попытка оптимизации?

КЛ>>По поводу const*. Это похоже на опциональный аргумент. Можно и NULL передать.
N>Да, как то я об этом не подумал, просто сбило то что реально в коде этой ф-ции не допускают её работу с NULL.

тогда не вижу смысла. еще одна лишняя попытка оптимизации?

КЛ>>>а что собенного в том, что интегральные типы передаются по ссылке? Может быть ты имел ввиду const&?
N>>Да. Именно так, забыл указать. Если учеть то что кастов никаких с этой переменной в этом коде не проделывают.
КЛ>лишняя попытка оптимизации?
КЛ>>>По поводу const*. Это похоже на опциональный аргумент. Можно и NULL передать.
N>>Да, как то я об этом не подумал, просто сбило то что реально в коде этой ф-ции не допускают её работу с NULL.
КЛ>тогда не вижу смысла. еще одна лишняя попытка оптимизации?

Ну так это я вопрос задал ок. спишем на какую то мега задумку код писавшего или на невысыпон, вот как у меня сегодня прям

Здравствуйте, night beast, Вы писали:

N>>Тратиться дополнительное время на один уровень косвенности, а памяти отъедает меньше чем фактический тип только в случае long long;

NB>какие нибудь цифры, поддверждающие предположение имеются?

В своей практике ни разу не встречал что замена функции вида

void f (const some_fundamental_type & value);

на

void f (some_fundamental_type value);

давала ощутимый прирост производительности. Но опираясь на классиков Andrei Alexandrescu хочу процитировать отрывок из его книги:

Modern C++ Design: Generic Programming and Design Patterns Applied
Chapter 2. Techniques
2.10.3 Optimized Parameter Types
In template code, you sometimes need to answer the following question: Given an arbitrary type T, what is
the most efficient way of passing and accepting objects of type T as arguments to functions? In general, the
most efficient way is to pass elaborate types by reference and scalar types by value. (Scalar types consist of
the arithmetic types described earlier as well as enums, pointers, and pointers to members.) For elaborate
types you avoid the overhead of an extra temporary (constructor-plus-destructor calls), and for scalar types
you avoid the overhead of the indirection resulting from the reference.

, так что не знаю кому верить: небольшому опыту или классикам. Для себя решил — нет константных ссылок на фундаментальные типы;

Здравствуйте, Константин Л., Вы писали:

N>>Тратиться дополнительное время на один уровень косвенности

КЛ>это ты о чем?

Это об операции разъименования (получения значения по ссылке);

Здравствуйте, np9mi7, Вы писали:

N>>>Тратиться дополнительное время на один уровень косвенности, а памяти отъедает меньше чем фактический тип только в случае long long;

NB>>какие нибудь цифры, поддверждающие предположение имеются?

N>В своей практике ни разу не встречал что замена функции вида
N>

N>void f (const some_fundamental_type & value);
N>

на
N>

N>void f (some_fundamental_type value);
N>

давала ощутимый прирост производительности. Но опираясь на классиков Andrei Alexandrescu хочу процитировать отрывок из его книги:
N>так что не знаю кому верить: небольшому опыту или классикам. Для себя решил — нет константных ссылок на фундаментальные типы;

верить надо цифрам тестов

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

Здравствуйте, np9mi7, Вы писали:

N>Здравствуйте, Константин Л., Вы писали:

N>>>Тратиться дополнительное время на один уровень косвенности

КЛ>>это ты о чем?

N>Это об операции разъименования (получения значения по ссылке);
Ссылки не разименовываются, разыменовываются указатели, а ссылка — это просто просто "псевдоним", другое название той же переменной. Ссылка представляет собой адрес в памяти, начиная с которого лежат данные.

Здравствуйте, Erlond, Вы писали:

E>Ссылки не разименовываются, разыменовываются указатели, а ссылка — это просто просто "псевдоним", другое название той же переменной. Ссылка представляет собой адрес в памяти, начиная с которого лежат данные.

Почему тогда дизассемблер показывает две абсолютно идентичные функции:

void f(int *i)
{
    *i = 5;
}

void f(int &i)
{
    i = 6;
}

int main()
{
    int k(0);
    f(k);
    f(&k);

    return 0;
}

Здравствуйте, nen777w, Вы писали:

N>Смотрю чужой код...
N>Не пойму одну вещ какой смысл объявлять передачу по ссылке в ф-ции для переменных интегральных типов и выведенных из них (typedef), то же вопрос касается передачи по константному указателю (не принимая во внимания того что можно сделать const_cast).
N>Компилятор как то особо обрабатывает такие объявления?

Есть 3 способа передавать аргументы в функцию:

1). по значению;
2). по ссылке;
3). по указателю.

В 1-м случае создаётся временный объект, в который копируется значение аргумента, и функция работает с временным объектом. Внутри функции значения переданных аргументов можно изменять, это изменение никак не отразится за пределами функции. Недостаток — непроизводительные потери на создание временного объекта и копирование данных, что может быть достаточно накладно при больших объёмах.

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

В 3-м случае почти то же самое, что и во 2-м, передаётся только указатель на данные, создания временного объекта не происходит. Отличия — указатель может быть NULL, при обращении к данным требуется операция разыменования (косвенная адресация).

Я думаю, что компилятор просто соптимизировал ассемлерный код, этот пример достаточно прост. Кстатии вполне вероятно, что переменной к вообще не создаётся, компилятор заменил её на константу, т.к. она не изменяет своего значения.

Здравствуйте, Erlond, Вы писали:

E>Я думаю, что компилятор просто соптимизировал ассемлерный код, этот пример достаточно прост. Кстатии вполне вероятно, что переменной к вообще не создаётся, компилятор заменил её на константу, т.к. она не изменяет своего значения.

Что значин "не изменяет своего значения"? Изменяет и ещё как (пример, вроде, достаточно простой, чтобы в нём разобраться). Она существует и создаётся.

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

Здравствуйте, Nuzhny, Вы писали:

N>Здравствуйте, Erlond, Вы писали:

E>>Я думаю, что компилятор просто соптимизировал ассемлерный код, этот пример достаточно прост. Кстатии вполне вероятно, что переменной к вообще не создаётся, компилятор заменил её на константу, т.к. она не изменяет своего значения.

N>Что значин "не изменяет своего значения"? Изменяет и ещё как (пример, вроде, достаточно простой, чтобы в нём разобраться). Она существует и создаётся.

N>Я, вообще, всегда думал, что передача по ссылке и по указателю физически представляет собой одно и тоже. Разница только в синтаксисе.

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

Здравствуйте, Erlond, Вы писали:

E>Здравствуйте, nen777w, Вы писали:

E>В 3-м случае почти то же самое, что и во 2-м, передаётся только указатель на данные, создания временного объекта не происходит. Отличия — указатель может быть NULL, при обращении к данным требуется операция разыменования (косвенная адресация).

Ссылка технически имеет семантику указателя, так что косвенность все равно есть. Вот выше товарищ про дизасемблер писал. Но у нее есть, так сказать, свойства в языке: 1) должна быть инициализирована, 2) указатель может изменить адрес объекта на котрый указаывает, а ссылка нет (точнее, изменится объект):

int foo = 0;
int bar = 10;

int* p1 = NULL;
int* p2 = &foo;
p1 = p2; //Pointer changed

int& r1 = foo;
int& r2 = bar;
r1 = r2; 
//Now 'foo' == 10, 'bar' == 0

Ну и синтаксис конечно. Ссылки не инициализипуются (синтаксически) если они параметры функции. Введение их — стремление немного обезопасить C++. Врядли они сильно помогают при оптимизации, кроме как cons T& в ситауциях типа:

class T
{
  //Pretty heavy definition
};

void f1(const T* p);
void f2(const T& p);

void f()
{
  f1(&T()); //Error
  f2( T()); //Ok
}

Здравствуйте, np9mi7, Вы писали:

N>Здравствуйте, Константин Л., Вы писали:

N>>>Тратиться дополнительное время на один уровень косвенности

КЛ>>это ты о чем?

N>Это об операции разъименования (получения значения по ссылке);

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

Здравствуйте, demi, Вы писали:

ну ссылку на источник уже пока привести.