Отличие int const& от int& - C/C++

В одной библиотеке я увидел обьявление:

XmlRpcValue& operator=(int const& rhs) { return operator=(XmlRpcValue(rhs)); }

Чем отличается это обьявление от просто:

XmlRpcValue& operator=(int& rhs) { return operator=(XmlRpcValue(rhs)); }

?

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

_>В одной библиотеке я увидел обьявление:
_>

XmlRpcValue& operator=(int const& rhs) { return operator=(XmlRpcValue(rhs)); }

_>Чем отличается это обьявление от просто:
_>

XmlRpcValue& operator=(int& rhs) { return operator=(XmlRpcValue(rhs)); }

_>?

да, известная библиотека, классная

я ее уже наполовину перестроил, доволен

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

_>В одной библиотеке я увидел обьявление:
_>

XmlRpcValue& operator=(int const& rhs) { return operator=(XmlRpcValue(rhs)); }

_>Чем отличается это обьявление от просто:
_>

XmlRpcValue& operator=(int& rhs) { return operator=(XmlRpcValue(rhs)); }

_>?

В первом случае функция не может изменить значение, на которое ссылается ее параметр, а во втором — может. В частности, первой функции можно передать ссылку на член класса из const-метода этого класса, а второй нельзя (без явного const_cast ).

А>В первом случае функция не может изменить значение, на которое ссылается ее параметр, а во втором — может. В частности, первой функции можно передать ссылку на член класса из const-метода этого класса, а второй нельзя (без явного const_cast ).

Разве int const& и const int& эквивалентны?

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

А>>В первом случае функция не может изменить значение, на которое ссылается ее параметр, а во втором — может. В частности, первой функции можно передать ссылку на член класса из const-метода этого класса, а второй нельзя (без явного const_cast ).

_>Разве int const& и const int& эквивалентны?

эквивалентны

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

А>>В первом случае функция не может изменить значение, на которое ссылается ее параметр, а во втором — может. В частности, первой функции можно передать ссылку на член класса из const-метода этого класса, а второй нельзя (без явного const_cast ).

_>Разве int const& и const int& эквивалентны?

Угу

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

K>эквивалентны

Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.

  const int d = 5;
  const int& a = d;

  int r=90;
  int const& b = r;
  r++;

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

V>Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.
V>

V>  const int d = 5;
V>  const int& a = d;

V>  int r=90;
V>  int const& b = r;
V>  r++;
V>

а у тя здесь только ссылка на константу, константной ссылки у тя здесь нету
константная ссылка вот:

  int & const

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

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

K>>эквивалентны

V>Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.
V>

V>  const int d = 5;
V>  const int& a = d;

V>  int r=90;
V>  int const& b = r;
V>  r++;
V>

Константная ссылка должна была бы выглядеть (подобно константному указателю) вот так:

int & const b=r;

Однако, все ссылки по определению константны: ссылка должна быть инициализирована при объявлении и затем не может быть изменена — можно изменять только значение, на которое она ссылается.
На вышеприведенный оператор MS Visual C++ 2003 выдает

warning C4227: anachronism used : qualifiers on reference are ignored

Константные же указатели вполне законны и могут быть полезны:

int b;
int * const ptr=&b;

ptr всегда указывает на одно и то же место в памяти, но значение по этому адресу изменять можно.

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

V>Может я чего не понял

думаю тебе будет полезно прочитать про правило чтения типа справа налево

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

V>Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.

Нет такого явления "неконстантная ссылка". Для простоты понимания — ссылка это разыменованная константа-указатель (на константный либо неконстантный объект)

V>

V>  const int d = 5;
V>  const int& a = d; // Ошибка: потеря cv-квалификации.

V>  int r=90;
V>  int const& b = r;
V>  r++; // и ты хочешь сказать, что теперь b!=r ?
V>

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

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

V>>Может я чего не понял

K>думаю тебе будет полезно прочитать про правило чтения типа справа налево

А порядок применения ключевого слова static какой?

static int varS;
int static varS;

в чем здесь разница?

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

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

V>>Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.

К>Нет такого явления "неконстантная ссылка". Для простоты понимания — ссылка это разыменованная константа-указатель (на константный либо неконстантный объект)

V>>

V>>  const int d = 5;
V>>  const int& a = d; // Ошибка: потеря cv-квалификации.

V>>  int r=90;
V>>  int const& b = r;
V>>  r++; // и ты хочешь сказать, что теперь b!=r ?
V>>

Нет, я хочу сказать, что в первом случае а ссылается на константу (она никогда не поменяется), а во втором случае b ссылается на "то, что может поменяться"

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

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

V>>Может я чего не понял, но по-моему ссылка на константу и константная ссылка это 2 большие разницы.
V>>

V>>  const int d = 5;
V>>  const int& a = d;

V>>  int r=90;
V>>  int const& b = r;
V>>  r++;
V>>

K>а у тя здесь только ссылка на константу, константной ссылки у тя здесь нету
K>константная ссылка вот:
K>

K>  int & const 
K>

ну да не доглядел

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

V>Нет, я хочу сказать, что в первом случае а ссылается на константу (она никогда не поменяется), а во втором случае b ссылается на "то, что может поменяться"

Чтобы не путаться с расположением квалификаторов относительно исходных типов, сделаем так

typedef int mutable_int;
typedef const int const_int;

mutable_int x;
mutable_int & rx = x;
const_int & crx = x;

const_int y = 1;
const_int & ry = y;

mutable_int & const xz = x; // error: type qualifier on a reference type is not allowed
//            ^
const_int & const cxz = x; // error: type qualifier on a reference type is not allowed
//          ^

Здравствуйте, <Аноним>, Вы писали:

А>А порядок применения ключевого слова static какой?

А>static int varS;
А>int static varS;

А>в чем здесь разница?

Формат простого объявления в Си++ упрощенно выглядит так:

<последовательность спецификаторов> <последовательность деклараторов>

К спецификаторам относятся: спецификаторы класса памяти (auto, register, static, extern, mutable), спецификаторы типов (int, char, bool, wchar_t, long, short, signed, unsigned, double, float, void, const, volatile, а также введенные пользователем имена типов или шаблонов классов со списками параметров, подробные спецификаторы типов, или определения классов и перечислений), спецификаторы функций (inline, virtual, explicit), а также typedef и friend.

Некоторые спецификаторы несовместимы между собой (например, signed float) или с некоторыми видами деклараторов (typedef int f()). В списке спецификаторов должен быть хоть один, определяющий тип объявления (кроме случаев объявления конструктора и деструктора).

Порядок, в котором следуют спецификаторы, несуществен.

Декларараторы разделяются запятыми. Каждый декларатор содержит ровно одно определяемое имя и читается "изнутри-наружу". Не будем углубляться в формалистику, вот несколько простых правил:

1. Слова auto, register, static, extern, mutable, inline, virtual, explicit, typedef и friend в деклараторе появляться не могут.
2. Звездочки, амперсанды, запятые и скобки появляться в спецификаторе не могут (за исключением случая, когда спецификатор является определением класса или перечисления).
3. Спецификаторы типов могут появляться в деклараторе только в прототипе функции.
4. const и volatile не могут встречаться в самом начале декларатора (могут только "прятаться за звездочкой").

Теперь рассмотрим несколько примеров:

// Спецификаторы                                          Деклараторы
int                                                       some_int;
int typedef                                               int_alias, *pint, **ppint, *const cpint = &some_int;
const typedef int                                         *pcint;
enum { good, bad }                                        good_or_bad, *ptr_to_good_or_bad = &good_or_bad;
struct {
    int                                                       a;
    float                                                     b;
    }                                                       a_and_b, &alias_ab = a_and_b;
int                                                       f(), *g(int), (*h)(float);
void static                                               u();
int inline unsigned                                       zzz();

Вот примеры некорректных объявлений:

int *static f(); // Звездочка может находиться только в деклараторе, а static - только в спецификаторе. Здесь они перемешались.
int z, const y; // const и volatile не могут находиться в начале декларатора ("const y").

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

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

A>void static u();

Что же возвращает ф-ция u()? Наверно void, а сама ф-ция имеет статическую область видимости. Но при чтении справа-налево получается абраказябра... не смог словами выразить

Здравствуйте, <Аноним>, Вы писали:

A>>void static                                               u();

А>Что же возвращает ф-ция u()? Наверно void, а сама ф-ция имеет статическую область видимости. Но при чтении справа-налево получается абраказябра... не смог словами выразить

Выглядит, конечно, необычно, но вполне допускается. Конечно, на практике так лучше не писать.

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

Здравствуйте, <Аноним>, Вы писали:

A>>void static                                               u();

А>Что же возвращает ф-ция u()? Наверно void, а сама ф-ция имеет статическую область видимости. Но при чтении справа-налево получается абраказябра... не смог словами выразить

Кстати, функция имеет не "статическую область видимости", а внутреннюю компоновку.

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

Вот это я, конечно, хватил:

A>

A>int typedef                                               int_alias, *pint, **ppint, *const cpint = &some_int;
A>

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

	От:	isk_ver
	Дата:	21.10.04 10:46
	Оценка:

	От:	ilnar
	Дата:	21.10.04 10:51
	Оценка:

	От:	Аноним
	Дата:	21.10.04 11:04
	Оценка:

	От:	isk_ver
	Дата:	21.10.04 11:07
	Оценка:

	От:	korzhik
	Дата:	21.10.04 11:10
	Оценка: