Для меня много чего в этом вопросе непонятно. Наведу пример с учебника. Есть функция мейн. И переменные: int х=6; int *y=&х; (*y)++; cout выводит что х=7 а *y=7; не понятно-почему изменилось х-значит ли это что указатель возле игрека как бы в цепляет х и соотвественно изменяет и х. То есть как бы присваивание идет слева направо а не наоборот как обычно и есть. Потом вторая операция где есть указатель и ссылка вообще не понятна. Если х это 5. Тогда &х=0х530-то есть его адрес. Почему тогда указатель y который приравнивается к этой ссылке равен просто х. Или это так есть в С-языке. А в С++ это и значит что х=&х это одно и тоже а последне значит что значение передается по ссылке а не по значению. Вот на уровне компилятора желательно бы обьяснить. Ибо в стандартном понимание для меня: y-это адрес; а *y-значение что находится в этой ячейке памяти.

int x; - переменная типа int
int *y = &x; - указатель на переменную x
int &z = x; - ссылка на переменную x

по сути, z и y с точки зрения компилятора это одно и тоже - переменная хранящая какой-то адрес. Разница лишь в способах доступа. С точки зрения программиста y - это адрес переменой x, а z - это псевдоним переменной x. Значение y (т.е. адрес) можно в любой момент поменять, а вот z нельзя назначить "псевдонимом" для другой переменной.

Здесь я это все детально разжевал.

На счет z у меня еще будет вопрос. Вообще в этом деле где то десяток таких вопрос в этой теме. Только ваше включение z может только заплутать понимание. Я вот не понимаю почему не написать просто *y=х если y:-адрес переменной х. Ибо адрес и самая переменная не может быть одним и тоже. Хотя если х=&х, то есть это значит что присваивание идет по ссылке то это обьясняет почему инкремент был и в y, и х. Ибо без ссылки такого небыло б. Или может я в понимание на что этот указатель указывает ошибаюсь. То есть значение *y-это и указатель на адрес и на само значение. Хотя это конечно не одно и тоже. Ибо y-это адрес х. Например в магазине ценник что хлеб стоит 10 руб., это указатель на то что цена такая, и то что цена равна этому значению. То есть понятие 'казывает' и 'равно' как бы тождественно. Потом если бы мы записали *y=х результат был бы неодинаков -6 и 7. [касательно выражение &z=х, то понятно что это ссылка. Буквально означающая что адрес z равен х. То есть как бы само значение z-неопределено, и может быть

Добавлено через 4 минуты и 55 секунд
любым]-это мне понимае согласно  пройденному в C без плюсов. Может в ооп-варианте это имеет другой смысл. Или если там на языке компилятора или транслятора это записано как аксиома то наверное так должно быть. Это не физика не математика, язык  как той как другой искуственное явление.

maxi2, у тебя какая-то путаница в голове.
Указатель - так называется ПЕРЕМЕННАЯ, которая хранит адрес.
int *y; - это объявление переменной y типа "указатель на int".
y = &x; - это операция присваивания переменной y адреса переменной x;
(*y)++ - это увеличение значения переменной, на которую указывает y, на 1. Это тоже самое, что x++, только не явно.

Если все перевести к ценникам на хлеб, то ценник - это переменная. А вот когда тебе дадут бумажку с надписью: "цена на хлеб находится в таблице1 на 10-й строке и 5-м столбце"; то эта бумажка будет называться "указатель", а надпись - "адресом".

Вот видите вы сами написали что  указатель y=&х. Например 100ая ячейка. В то время как значение на которое он указывает или Ячейка хранит *y=х. Например 1, или 9млн. Если мы изменим х, то и *y должен поменяться. То есть ячейкам памяти не поменялась. Понимаю что и правильно обратное если нет поправте: например *y=1; потом мы присвоили *y=99 так и Х поменялась. Здесь вроде не вопрос. Только вы я думаю не совсем верно пояснили адреса на ценнике. Ибо как раз где этот ценник находится-магазин, правый верхний угол витрины это его адрес, даже буквально. А значение на нем написано-это и значение на которое указывает указатель-*y. Так и в книгах  рисуют. Да и сам ценник-его цвет и форма не интересует, как не интересует физический адрес ячейки памяти а ее электронный адрес. 

Может действительно C и C++-в этом вопросе отличаются ибо в учебнике по плюсах написано новый тип даных ссылка. Учебник очень недавний. Например следующий случай: речь идет о целочисленных даных: х=11; int & y=х; y++ ; результат тот же х и y равно 12. Хотя значение ссылок на х и y не приведено в коментариях. То есть непонятно значение int & y точнее значок ссылки должен быть возле инт, возле y, посредине как здесь или это не имеет значение? То есть я понимаю здесь тип int& а если написать &y-это будет неправильно. Хотя недумаю что компилятор здесь все разберет. То есть в этом примере непонятно почему не можно было написать y=х-результат был бы этот самый после инкремента.

+1  


maxi2, как по-Вашему, что такое адрес переменной в памяти процесса?



А если написатьбудет это правильно?
Как по-Вашему, какие типы у следующих переменных:???

Это сообщение отредактировал(а) feodorv - 6.11.2013, 22:15

feodorv, ты жестокий.   

bsa, есть немного   

x и есть *y, а ты их видимо как разные вещи воспринимаешь.
Может лучше привести сравнения с файловой системой чем с хлебом и другими продуктами питания?


Что понимается под электронным адресом? Электронный адрес и есть физический в рамках программирования, это некий номер, который хранит указатель.
А под "физическим" ты что, имел ввиду типа где располагаются транзисторы в чипе от левого верхнего угла?

maxi2,  имхо ты сам себя запутываешь, понимай так как объясняется, не надумывай свои вторые-третьи смыслы..


Касательно синтаксиса объявления ссылки: MSный компилятор пропускает все 3 варианта. Лично я бы посоветовал при объявлении и указателей и ссылок значки ставить у имени переменной, потому что объявления могут производится перечелением через оператор ","

Здесь z и k разного типа.
Так понятнее будет



Касательно путаницы что, где и когда использовать симолы взятия адреса указания типа или обращения по адресу: в языке некоторые обсалютно разные вещи используют одинаковые символы "*" и "&". Вариантов несколько "обозначение типа" при объявлении или приведении и "операция" (взятие адреса, обращения по адресу, умножение, бинарное или логическое И).

Нет вернемся к первому примеру.  Х=6; а *y=&х-то есть *y не равно х. То почему же и то увеличились на единицу. Или &х это не взятие адреса, а ссылка что компилятор ее понимает по своему. То есть по вашему и *y=&х и *y=х это одинаковые вещи? Ведь ссылка увеличивается на размер типа даных если в этом смысле понимать адрес х.  // физ. адрес я образно имел ввиду координаты ячейки памяти что хранит это значение, то есть какой то триггер или что то вроде этого в микросхеме

maxi2, ты путаешь вещи.

Ну что я конкретно путаю. Зачем в этой пример вплутывать еще и z,u. Вы говорите таким манером: типа грузия это горная страна или страна кавказа. И для ее пояснение наводите пример что вот если приравнять непал и швейцарию то она будет ближе к последней. Не много ли неизвестных. Вот не успел отослать: То есть важно проанализировать даже первую строку. Если х-6. То адрес неопреден. Если *y-указывает на на адрес и он увеличивается на единицу то адрес должен увеличиватся на 4-тип int. Или может дело в том что *y не может указываеть адрес переменной потому он сразу указывает на переменную х. Даже если так важно так сказать определить природу указателя. Если а=b, то если а++, то это не значит что и b увеличилось.  А вопрос очень прост: что &х и х имеют одно и тоже значение. То есть адрес и значение ячейки одно и тоже.

Добавлено через 4 минуты и 58 секунд
Хотя надо ввести этот пример в компилятор-ну там два для C и C++-может и результаты разные будут. А потом воспринимать как есть. Хотя воспринимать без реального понимание. Это ничего не даст.

maxi2,  bsa дал исчерпывающий ответ, к чему тут твои аналогии(которые, лично мне вообще, не понятны)?

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

P.S.maxi2, вместо написания простыней текста, без разделения на абзацы, ты бы лучше подольше подумал и сформулировал четкий вопрос. Так быстрее ответ получишь.

*y - это есть x. не копия, не привязка. а именно x. Наглядный пример: y - это бумажка, на которой можно писать, x - это квартира, y  = &x - это написать на бумажке адрес квартиры, *y - это пойти по адресу, который написан на бумажке. В итоге, делая *y ты получаешь то же, что и делая x - попадаешь в квартиру.
Это не ссылка, это взятие адреса. Т.е. если x - это квартира, то &x - это адрес квартиры.
Это разные вещи. Просто ты выдираешь из контекста. Операция инициализации переменной при ее объявлении отличается от присваивания синтаксисом. int *y = &x  и *y = x - это разные операции. Первая инициализирует указатель адресом, вторая копирует содержимое x в переменную, на которую указывает y. На примере с квартирами: первая - это взять бумажку из пачки и написать на ней адрес квартиры x, а вторая взять все содержимое квартиры x и отправить в квартиру по адресу, написанному на бумажке y.
Ссылка не увеличивается. Тут вообще ссылок нет. int &u - это ссылка, а int *y - это указатель. Когда ты делаешь *y ты получаешь переменную, на которую указывает указатель. Затем ты к этой переменной применяешь оператор ++ и вызываешь приращение. ТЫ НЕ МЕНЯЕШЬ УКАЗАТЕЛЬ, ТЫ МЕНЯЕШЬ ПЕРЕМЕННУЮ.

Все это я тебе написал в простом коде с комментариями.

Объявление переменной, инициализацию переменной и операцию присвоения  

http://ru.m.wikipedia.org/wiki/Ссылка_(C%2B%2B)--вот там есть такой самой пример. Хотя применение двох значков *  *-как то непонятно причем они к &. Может *y-не может указывать на адрес, ибо &х-это взятия адреса хотя учебнике идется о новом типе даных ссылки. Ибо если буквально *y-бы указывал на адрес, то y-это был бы другой адрес, а я понимаю что y и &х-одно и это самое. Тогда возникает вопрос а если б8 выражение было бы y*=х-результат бы был этот самый тот самый, какой смысл тогда применять значок -&. Даже так если огласить y=&х-такой же результат должен быть?

конгениально

maxi2, про указатели ты примерно понимаешь: y=&x означает поместить в y адрес х. *y означает значение по адресу y. при изменении *y изменяется х и наоборот.

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

теперь сложные выражения.
сначала пример - унарный минус y = -x
мы можем применить его дважды y = - -x // y=-(-x)
или трижды y = - - -x и т.д.
то же и с указателями.
если z это адрес не переменной, а указателя, то получить значение переменной можно двойной операцией разадресации


теперь ссылки + указатели
тут все довольно просто: если y это ссылка на х, т.е. синоним, то операции с указателями на y суть операции с указателем на х.

когда встречается комбинация унарных выражений, её следует понимать, читая справа налево:
y = - - -x // -(-(-x))
y = *&x // *(&x), т.е. значение по адресу на которое указывает адрес х, т.е. значение х
**z; // *(*z), т.е. значение по адресу на которое указывает значение по адресу z

Хорошо последний пост еще прочитаю более внимательно, а то уже хвалили как ученика n-класа. Я вот обратился к запуску кода. Я спросил если написать *y=х-которое есть 5 то компилятор ругается и говорит что неправильный перевод типа от int до int*. Если написать y=(int*)x, то код компилируется но при исполнение зависает консоль? То что y=&х есть адресом одной переменной я уже дважды или трижды сам писал. Но тогда y*=х и если сделать перед выводом это присвоение то будет ошибка. Но *y= и х и адресу (или ссылки) х. Ибо если  напишу в си-аут то оно выводит &х=0х5565, и мы это значение присвояем *y которое равно в результате 5. Что по вашему эти две цифры одно и тоже? Пусть даже адрес идет 8ричной системд. Вы лутше поясните что выражение *y-не может указывать или равняться адресу а автоматически переходит на значение которое оно содержит?

То есть непонятно если а сперва присвояется 5244 а потом оно выходит равно 5 это трудно понять. Вот еще пример int *p=(int *)7; int* &q=p; q++; cout <<p<<q// 11  11-то есть если p-адрес Значение 7, а q-то же самое что p, а p=эквивалент &х-то здесь условно понятно. Просто думал что выражение *y=5 верно, а выходит надо приведение типов. И думал что *y=&х не имеет смысла. Ибо правая часть это взятие адреса а это ссылка то есть то же самое что написать &х=х-ведь есть же &y=х-но как компилятор разграничивает эти два понятие точнее взятие адреса и ссылку. То есть как самому это обозначить при написание кода?/ о том что это синоним я может не так прочитал ибо пример: флоат пи=3,14; &n=пи; где &n-не меняется вообще. 

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

maxi2, это две очено большие разницы.
Именно этого вы не понимаете. подумайте над этим.
И напишите словами что будет в перой строке, что во второй.

Вы извините за повторение текста  и прочие, нет обычной клавы да и ПК, потому то что настрочил, потом надо закинуть сюда-потому и простыни текста.  Отвечая на вопрос скажу что если int a=5; то и a=5--если не так вы наведите результат. Вот там в примере если сперва предопределить х, а потом *y=(int*)х--то не работает, а *y=(int*)5-работает?

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

Это что по вашему какой то социологический опрос. В первом случае вы присваиваете целое значение по адресу y, а во втором случае извлекаете знчаение по адресу y, если вы это спрашиваете безотносительно примеров приведеных в этой теме, которые взяты из подраздела книги Новый тип Ссылка, которые менее более понял. Еще новое узнал, что *y=&x--это значение ячейки х. А не его адрес, а *y=х--вообще не компилируется без приведение типов: int *y=(int*)4, a int *y=(int*)x, если х уже определено--- нет.

maxi2, вам просто пытаются помочь, только эффективность маловата...
Синтаксис вы неправильно понимаете.
В первом случае 

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

не извлекается, а наоборот присваивается значение по адресу. если две строчки рассматривать вместе, то во второй значение присваивается тому, чей адрес присвоен y в первой.

Нет, конечно. Это лишь наводящий вопрос, призывающий Вас разобраться в Если Вы в этом не разберётесь, то никто за Вас не разберётся. 



Абсолютно нет. Запись означает лишь объявление переменной с именем "y" и типом "указатель на int". Запись означает лишь объявление переменной с именем "y" и типом "указатель на int" и инициализацию этой переменной (задание значения в момент объявления) адресом переменной x. Никакого присвоения целого значения по адресу y здесь нет и в помине.


А вот здесь как раз есть:Здесь-то как раз присвоение целого значения по адресу y. 


Аналогичная ситуация с ссылками. Из-за непонимания этих простых истин и возникает всё Ваше недоумение.



Это не так.



И не должно. Указателю можно присвоить только какой-нибудь адрес (например, значение другого указателя или результат операции взятия адреса), а не значение целой переменной. Когда вы пишете (int*)4, то превращаете целочисленное значение 4 в адрес. И опять возникает "социологический опрос":Что это - абстракция или какой-то значение с каким-то смыслом?

Да я неправильно понял ваш вопрос и вот хотел теперь посмотреть на форум и здогадался, что инт *г=&х, должна быть с амперсандом-ибо иначе ошибка компилятора. а *Г=х,это обычно присвоение. Но трудно понять почему в первом случае вы говорите что идет присвоение адреса, ибо тогда можно было написать г=&х. Потом в основном примере темы нету выражение *г=х, то есть присвоение гласно не гласно идет в первом случае *г=&х, когда как бы одновременно указывается что г=&х, а *г=х. Хотя непонятно что все таки в учебнике этот амперсанд значит-взятие адреса или ссылку. Ибо если последнее оно вроде в левой части в остальных примерах. Касательно приведение типов то я имел ввиду что код х=2; инт *г=(инт*)х-не исполняется но компилируется, а инт *г=(инт*)3-работает.

Вижу что замечаний нету. Теперь хочу перейти к теме использование ссылок в функциях. Вот здесь очень интересный пример очень похожый до выражение что мы использовали перед этим. То есть как бы  &х равно х, и хочется знать что будет если использовать без знака ссылки void fun (int &y) {y++;} ...main () {int x=1; fun (x); cout<<x<<endl; } //2- a если без знака ссылки-то было бы 1 или 2. Естли void fun (int *y) {(*y)++; } ... main () { int x=1; fun (&x); cout<<x<<...}//2.  В первом случае я так понимаю что это не знак взятия адреса а ссылка то есть ибо тогда в функцию бы передавалось не значение а адрес.то есть если проще это выражение типа-инт &y=х-вот уже по ходу понял как привязать декларацию и инициализацию функции. Во втором случае-уже заежженый вариант-инт *y=&х, с чего выплывает-*y=х.  А то если не приравнивать обьявиение и инициализацию снова ничего не понять.

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

Судя по способу твоего изложения своих мыслей и скорости восприятии информации можно сделать один вывод - ты или де*ил, или творческая личность. Но ни тот, ни другой не способен освоить С++.

Если же так хочется, то забудь о конструкции int *y = &x; используй вместо неё int *y; y = &x;

Ну-ну, я в ваш адрес могу эту букву и написать. Пусть вы и эксперт. То что вы не хотели связываться это ваше дело, только  на кой ... было это дискусию может быть бесполезную продолжать, и именно тогда когда может менее более разобрали по полкам. Если замечание есть-жду критики. Правда освоить c++ трудно именно через сабж этой темы. Особенно если делать это самому. Кроме того как и каждый язык-это искуственно- и это надо воспринимать как оно есть. Другие языки как раз не имеют такого синтаксиса, и это упрощает работу  и уменьшает ошибки. В том то и дело что в школе я разве програмирование не учил, ибо его не было, а если бы было то думаю в паскале указателей и ссылок нету.  

Вот если во второй функции в обьявление есть указатель, а при инициализации идет ссылка которую можно поплутать с взятием адреса, то я и написал что нужно приравнивать. Ибо раньше такое встречалось и было непонятно. Если аргумент функции меняет тип то как это понять. Например есть у меня 3ья функция: по вашему что бы быть програмистом надо быть еще каким то прорицателеm. x=2; void fun(int &y=x) {y++;}... main fun (); -тогда х и y синонимы и равны 2// func(z) -z и y-синонимы-то есть уже зед увеличивается. В этом примере не так просто догадатся что в первом случае параметры функции будут-&y=х; а во втором-&y=z; вот последнее выражение понятно как солнце в ясний день.

maxi2,  не хотелось влазить, но тем не менее спрошу. Вы пытаетесь людей знающих с++ как то на свой лад переучить?

Кстати меня так выправляли, но всетаки не выправили: то что в правой части это как раз взятие адреса, а в левой это ссылка: это поспешность в чтение материала. Так и в функции: в первой это адрес-а во второй-ссылка. я вас и спрашивал как компилятор отличает: вот по левой или правой части и отличает. Если бы были такие опытные это бы в два счета обьяснили. 

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

maxi2, по правой части решение применяется только в стандарте С++11 при использовании типа auto. Но тебе еще о нем знать рано. Тип операции вычисляется для левой и правой частей независимо. И если типы несовместимы с операцией, то выдается ошибка.
Я тебе уже написал, что операция int *y = &x; выглядит как две:
1. объявление переменной y: int *y;
2. инициализация ее адресом переменной x: y = &x;

Просто не понимая таких простых вещей ты никогда не сможешь понять более сложных, например: int *y = &x, &z = n, *&q = y;
Еще раз вдумчиво перечитай то, что тебе писали тут ранее. Я тебе даже примеры приводил. Попробуй проанализировать каждую их строку.
И не надо пытаться догадаться как работает компилятор. Тебе на данном этапе это только помешает.

На будущее. Если в начале операции участвует тип вне скобок, то эта операция является объявлением переменной(ых).
В паскале они есть. Другое дело, что для работы с указателем там много геморроя придумано. А ссылки только процедур/функций используются (var в списке параметров). Да и называется там все это иначе, на сколько я знаю.
Во-первых, данный код, написанный вне тела функции вызовет ошибку (из-за x=2 - вне функций нельзя выполнять присваивание, как и другие операции, кроме объявлений типов, переменных и функций). Во-вторых, обычно, в качестве дефолтных значений параметров функций используют некие константы.

Я никого не хочу переучить. Если б я десятки или даже сотни часов приделил c++ то многое было понималось само собой. Вот очень интересный пример о ссылках функциях: и меня коуд блок почему выводит одинаковый результат тип ли это инт& или просто инт. int x=5; int& fun1(int y) { x+=y; return x;} void (у меня работает лиш int?) main () {cout<<fun1(2)<<endl; cout<<x<<endl;}//7     7-какой смысл такой функции ссылки если без амперсанда получается это самое.

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

Смотрите если есть int q=3; то и q=3; я ишел по логике что если заменить q=*y-то ничего не поменяется. Я вам уже наверное пять раз писал что меня здесь раздражает: если int q равняется, указывает на адрес почему оно потом без типа инт уже равно значению что есть в этой ячейке. Ну пусть. Это можно взять за должное ибо законами физики или математики это не понять. Это так придумали. Если работает. Все хорошо. А насчет правой и левой части это так и есть ибо ссылка обьявляется &z=х, а не наоборот. Вы меня простите, но если бы записывали int *y=х, и это все воспринимали то ничего бы особо не изменилось и было бы логичнее.// что значит возвращает ссылку-это адрес или синоним. Она ведь возвращает значение х.

maxi2, ну как тебе еще объяснить, что int *y; - это такой синтаксис языка объявления указателей. int *y = &x; это тоже самое, что int *y; y = &x;
Запись &z = x вообще недопустима. Ты присваиваешь адресу какое-то значение. А вот int &z = x; - это совсем другое. Это создание ссылки z типа int на переменную x. 

maxi2, зачем ты мне какую-то цитату приписываешь? Я такого не постил.


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


Ссылка так не объявляется.
Ссылка объявляется так:

я вот больше склоняюсь к варианту 


в том числе и потому, что такое написание позволяет визуально разделить объявление переменной и разименование.

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



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

Выбегалло

Это сообщение отредактировал(а) baldina - 11.11.2013, 09:20

Последнее это наверное склонность к итальянским фамилиям. Я вот приведу пример откуда начиналось мое понимание указателей, и оно несколько не похоже на ту строку которую мы уже обсуждаем несколько дней.  int *mypointer; int first, second; mypoimter=&first; *mypointer=10; mypointer=&second; *mypointer=20;¥ c++ language tutorial (cplus.com)-stranica 66. Поясните все таки что значит возвращает ссылку. В одном из вышеприведеных вариантов и вообще. Например функция int& fun2(int &z) {z++; return z;} ...main () {int x=5; fun2(x); cout-x-10. Почему функция возращает 10. А не 6. Или надо воспринимать это как &fun2=х-а как левая часть десять то и х=10. Или наоборот. Ибо функция возвращает х. Какая то обратная зависимость? У меня прогерского мышление нету потому обьясните пожалуста-и для чего здесь пост-инкремент?  

cout - это объект ввода вывода, его нельзя складывать, отнимать и т.д.

Если нет мышления, то хотябы переписывать научитесь внимательно.

это тест на причину вот этого 

теперь диагноз ясен - мал читательский опыт

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



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

Я извиняюсь. Об указателях кроме уже известного варианта я давно понял. Проблема с указателями с обектами, думаю до этого еще дойдет. ССылки тоже понятно. Пмевдоним так псевдоним. Но вот с функциями не так и просто. Я спрашивал, что значит возвращает ссылку если как таквой нету: ведь например в парамеитрах обявляется ампер-х, а инициализируется зед, или наоборот. Тогда единый выходт приравнять. Но вот если функция имеет тип ссылка это сложнее. А о компиляторе я спрашивал, потому тчо он то точно действует неким инструкциям, а не воспринимает на веру, или как ему вздумается. А о том что надо понять каждый шаг, то это я и спросил первый. Если электортехник или архитектор должен приблизительно представить что он проектирует, так и здесь как бы оно абстрактно не выглядело, ведь здесь тоже физическая основа. А о том что у меня нету мышление прогера то я имел ввиду что может оно появится, хотя бы наполовину, ибо то что голова не будет лиш одним кодом забыта то однозначно. Я вам приводил примаер с англоязычнго учебника и такая строка что мы уже разбираем уже долго не употребляется, ибо она алогична по своему смыслу вот и все. А о функциях хотел бы чтобы пояснили.

Ссылка как таковая есть. Эта функция получает ссылку на объект и возвращает, самми ссылки может и являются отдельными объектами но ссылаются то на один, это самое главное. Ссылки введны для удобства написания кода а не построения алгоритма (хотя может меня поправят   )
http://ideone.com/W86QoB


Добавлено через 3 минуты и 12 секунд
Если бы функция возвращала int а не ссылку на int то запись fun2(fun2(x)) была бы неверна.

Здесь тоже разбей на два этапа. Сначала работа с ссылками на уровне переменных:
1. взятие адреса



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



3. возвращение значения по ссылке


В этом, последнем, варианте, как я понимаю, есть свои, значительные особенности, связанные с поведением и временем жизни. Это ты вообще можешь оставить напоследок. Потому что там есть свои особые фенечки. Ты к ним можешь вернуться и чуть попозже, после того, как на практике уяснишь и закрепишь всё остальное.

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

 яимел  виду что ссылка это альтернатива другой переменной. Например инт а=5; инт &б=a; а в функциях это лиш так приблизительно, ибо есть только амперсанд. Хотя без ссылок то функция тоже обьявляется разными параметрами sum (int a, int b) а инициализируется sum (x,y).

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

В последнем стандарте С++ появилось понятие lvalue-reference (в вольном переводе - ссылка на значение/временную переменную). Она задается двумя амперсандами: int &&r; Используется преимущественно в качестве параметров функций и методов.

То есть например в класе вектор-в конструкторе копирование ссылка точнее тип ссылки идет лиш для того чтобы не копировать весь экземпляр класа? И если бы амперсанда не было то просто процес копирование был бы сильно ресурсозатратошным уже именно через внутреннее копирование ?class vector { float *u; int size;}.... vector::vector(const vector& a) {u=new float[size=a.size]; for(int i=0; i<size; i++) u[i]=a.v[i];}. А для чего ключевое слово констант-в каком смысле параметр этого конструктора может изменится? То есть что изменится если его не будет. Хотя по ходу понял что мы можем как раз изменить а.v[i] например а.v[i]+1, и как раз ссылка это позволяет или без нее и слово const это можно сделать?

Добавлено через 7 минут и 21 секунду
Сорри v-то же самое что и u. Так для изменение оригинала.  

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

Ну а почему не сможет. Задам детский вопрос: что ему мешает? И почему конкретный обьект есть константой? Потому что он соответствует класу который имеет некоторую структуру которую не возможно изменить. Например два поля и три метода? Хотя увеличить на 1 как я привел как бы ничего не мешает? Конструктор вроде метод(функция) тоже с именем класа? То есть где там константа, и если она есть для чего параметр обозначать константным, то есть что это дает кроме того что компилятор увидет это слово и появится ошибка.

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

Действительно   

В языке FORTRAN 4 все параметры в процедуры по умолчанию передаются по ссылке. В первых компиляторах FORTRAN'а они (компиляторы) не контролировали константность того, что туда передавалось. Кроме того, для часто употребляемых констант (типа 1, 2 и т.п.) заводились внутренние переменные, которые содержали эти константы (из за особенностей аппаратуры, это были кажется IBM 360)

После чего, вызов типа CALL func(1) при ее реализация типа
приводило к тому, что дальше по всей программе число 1 вдруг становилось равно 2   

Кстати о функции копирование вот она приведена из типом ссылка. В отличие от конструктора копирования. class Base { int x,y; public: Base& Copy (const Base& a) { x=a.x; y=a.y; return *this;}};  то есть для чего тип ссылки в этой функции. В этой теме есть подобный вариант где я задал вопрос для чего амперсанд если он ничего не меняет: может в этом варианте это имеет значение ибо это так сказать ооп-функция?

maxi2, как иначе создать фукцию копирования? Передавать ей параметр через указатель? Ведь по значению нельзя - требуется копирование.

Ну нет по значению как раз осуществляется копирование. Здесь как бы и осуществлена функция копирование по значению которое происходит на уровне компилятора или транслятора. Хотя это такое дело. Я все таки не пойму почему перед Copy ставить значок & что это меняет. Ведь функция тоже какой то обьект в памяти. Для чего ее обьявлять типом ссылки. Это псевдоним чего, или это адрес. Что вообще меняет этот амперсанд. В параметрах разобрались. А здесь. Ведь выше по тексту есть пример так там и с ним и без него функция возвращает это же значение. Хотя там тип ссылка на int. Указатели в C, а здесь плюсы 2. Возвращаясь к особеностям c++. Очень удивляет такой синтаксис оглашение элементов класа-полей и методов. Например: int Ваsе::*p=&Ваsе::х-поле этого класа. Для чего ссылка после присваивание. Она была бы логичней перед х. А здесь класы типа-Base=&Base-похоже на взятие адреса хотя это клас, а не на ссылку где  &-в левой части. А уже легендарное здесь в теме: *p=х--без ампера-это что так натолкнуло на такой синтаксис штрауструпа.

Добавлено через 5 минут и 44 секунды
Хде логика?

Не перед Copy, а после Base. Значок референса относится не к имени функции, а к типу возвращаемой ею величины.


Это не ссылка, а взятие адреса.

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


У вас полная каша в голове, и её отголоски отлично видны в ваших сообщениях - понять их почти невозможно   

Ну каша пусть это уже собственно моя проблема будет. Но если бы все было ясно, точнее однозначно то я бы этой темы не создавал. О функции- в чем смысл ампера ответа не дали. Да и вообще что значит возвращает ссылку(адрес, псевдоним?). Что там перед или после это смысла не меняет-ибо для одного после для другого перед. А вот декларирование полей вы не ответили. Если расщепить последний пример на два. То выходит что ВАSЕ=&ВАSЕ, и *p=х, а не *p=&х-на котором уже мозоли набили. Логичнее было int Ваsе::*p=Ваsе::&х? Не так ли. Или в авторов языка какие то причины были на такой неровный синтаксис?

Не так   

Извините за оффтоп, но весьма радует спор о правильности синтаксиса с++ человеком который "синтаксиса" русского языка толком не знает. Мне кажется все это надо было Страуструпу писать. 

Это сообщение отредактировал(а) ldir - 24.11.2013, 23:37

maxi2, ты троль?
Ты игноришь ответы, которые тебе дают. Это видно по твоим вопросам, на которые уже давались ответы. То есть ты не читаешь что тебе отвечают, а просто делаешь вбросы.
Предлагаю закрыть тему, лулзов достаточно.

Это сообщение отредактировал(а) EgoBrain - 25.11.2013, 03:20

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

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

Напишите словами, что будет в первой строке, что во второй.

Это сообщение отредактировал(а) NoviceF - 25.11.2013, 08:11

Нет, вы что каким то китайским юмором хотите меня удивить. int *y=&z; *y=z; мы уже на это перед этим месяц затратили. Уже кажется новый суто формальный вопрос остался. Декларация полей и методов класа с помощью указателей? Еще пример с этой области< const int Base::*p=&Base::x- main () { Base a(1,4); //a.x=6; nelzya// a.*(int Base::*)p=6; так можно но все таки трудно это понять особенно то что в скобках. Выходит какой то двойной указатель получается или такое приведение типов.  А вот еще один Ньюанс c++--указатель на статическое поле класа оглашается так. int *p=&Base::x- почему здесь нету имени класа в левой части не пойму?  Потом методы почему то в скобки берутся-- int (Base::*p) ()=&Base::GetY

Считайте, что ссылка - это особый вид указателя. Все опрации со ссылкой компилятор перед тем как компилировать преобразует в нечто иное (прямо в текством виде). А именно:
При инициализации вместо
подставляется
Т.е. ссылка заменяется на указатель, а от того, чем ее инициализировали берется адрес.
При дальнейшем использовании все обращения к a заменяются на (*a). Собственно это все.


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


Ну такой уж он есть, что поделать   


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

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

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

Строка 1 значит - ... 
Строка 2 значит - ...

Как можно лезть в указатели на член класса, когда ты не понимаешь чем ссылка отличается от указателя?

Это сообщение отредактировал(а) NoviceF - 25.11.2013, 14:25

Ссори, не метод, а указатель с класом на метод. Вообще удивительная конструкция-скобки имеют тип целое и указатель. 

Это приведение типа. 

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

может все же с чего нибудь попроще начнете?   



Статические члены класса фиктически не являются членами класса, так как им не предается this (для методов), или они находятся вне любого класса (для переменных). Поэтому указатель на них будет указателем на обычную функцию/переменную.


Это описание типа (еще один большой подводный камень подводная скала подводный айсберг синтаксиса С++ и С) - описание указателя на функцию.

Хинт, как читать описание типа - отделяете слово с именем типа вначале описания (в вашем случае это int), затем ищете имя переменной (это p). Затем применяете все, что написанно около идентификатора переменной (по правилам посроения выражений в С), в результате получите ваш тип с первого места (int)
Порядок применения:

•  К переменной p применяем оператор ::* (от класса типа Base) (т.е. p - это member pointer)
•  К результату применяем оператор () - вызов функции (т.е. p - это member pointer на функцию)
•  В результате получаем int ((т.е. p - это member pointer на функцию, возвращающую int)

Нет это вы уже загнули, что не знаю чем указатель от ссылки отличается. Как и выражение о скользком леде: был бы язык попроще давно бы все было бы понятно. И интуетивным-а не так одно как бы противоречит другому. То что это все теория я даже не хочу эти коды проверять в компиляторе ибо и желание нет и потребности. Пишу это все с м/т так что воспринимайте мои записи как я воспринимаю синтаксис плюсов. Но в примере о полях класа, зачем взятие адреса класа. Я все таки думал что бейс относится к бейс, а *p к 'х' как разные уровни организации структуры. И как то они должны соотносится с тем что мы да и другие прогеры проходили перед этим. Ибо если не будет порядка и логики так и не будет ее в умах. Вот даже пример из статическим полем--где там бейс дели. Или если это указатель на статическое поле и оно как бы общее для всех класов кажется так зачем там обозначать клас. Но он есть. И именно перед полем но не перед указателем? Я все это пишу ибо если если синтаксис такой специальный то есть существенно отличается от случая до случая так потом очень легко заплутатся. Особенно в сложном коде.

Так возьмите другой язык, попроще (Java например), зачем мучиться?   


Вы все пытаетесь придумать свой 'порядок и логику', и удивляетесь, почему они вдруг не совпали с тем, что есть в С++   


Вы неправильно думали. Возьмите наконец описание языка и почитайте, там все описанно. Конструкция ::* в Base::*p это одна лексема, и нельзя :: отнести к Base, а * к p


Нифига не понял. Какой класс там есть и какого класса там нет? И о каком классе вообще идет речь?


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

Да не сгущивайте краски. Никто здесь не мучится. Я как раз написал что даже на компе проверять эти коды нету надобности. Пытаюсь понять это теоретически. Ибо какая то база есть. В том числе и на ява и на простом C. И кирпичики я  понял, но в плюсах такие конструкции что некоторые кирпичи как полстены кажутся. Я для чего эти все вопросы задавал. Как раз чтобы все главные кирпичи и определить. Я понимаю что в чужой монастырь не ходят. Но он и мне не такой чужой. А то советы о том чтобы взять попроще вообще непонясны. Если можно понять что int a; это переменная целогочисленног типа. То можно запомнить то как используясься указатели на даные класа. В этой теме я четко понял одно. Что int *p=&x; это инициализация указателя (или переменной на которую он оказывает) что я не знал. А *р=х-это вызов вышесказаного. Вот его применение в функциях и в обьектах это сложнее. Так что поехали есть еще вопросы. А ваши другие советы думаю позже еще использую если буду что то кодить.

Без практики это тухлое дело


Странно что на это понадобилось так много времени и стольких усилий: этот факт открытым текстом в любой книжке по С/С++ написан. Думаю дело в том же - низком уровне сознания в ЯП, обусловленном отсутствием практики.