В программировании использование ссылок в написании кода применяется очень часто. Самый логичный вопрос, который обязан возникнуть у начинающих
- "Что такое ссылка?"
В стандартных определениях можно найти такое - Ссылка - это альтернативное имя, это псевдоним объекта и прочие определения, в которых говорится, что ссылка - это второе имя конкретного объекта.
 На самом деле, чтобы лучше понять что такое ссылка нужно познакомиться с унарной операцией взятия адреса. Вот откуда бедному начинающему студенту знать что такое "унарный"? Унарный - это операция над одним операндом. А что такое операнд? - по мне это лишние слова, которые вносят некоторый сумбур в обучение и отвлекают от минимума необходимого

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

void main()
 {
  int a=100;
  cout<<a<<endl; //Выводим значение а = 100
  cout<<&a<<endl;//Выводим адрес по которому а расположена в памяти

 }

 В первом случае было использовано хорошо знакомое выражение, выводящее значение переменной на экран.
 Во втором случае был использован знак & перед переменной. Этот знак сообщил компилятору, что автор программы хочет обратится к адресу переменной а. На экран может вывестись что-то типа a*fff4

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



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

void main()
 {
  clrscr();
   int x;  //x- это обычная переменная. При этом x есть объект типа int
   int &a=x; //объявляем ссылку а. a ссылается на x (любая обработка  a это обработка x)

  getch();
  return;
 }
=====================
 Тут видно, что во время инициализации а, а берет адрес у переменной x, Проинициализировать дважды один объект нельзя, ссылка не исключение, поэтому на время своей жизни, переменной а будет соответствовать только тот адрес, который был ей присвоен во время объявления. В приведенном примере этот адрес есть адрес переменной x

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

Код С++ Ссылка = Псевдоним объекта
====================

 void main()
  {
   clrscr();
    int x=100;
    int &a=x;
     cout<<"a = "<<a<<endl; //Вывели значение a (a=объект из адреса x (a=х),  x=100 => a=100)
     cout<<"x = "<<x<<endl; // Вывели значение x (x=100)
     cout<<"&a = "<<&a<<endl; //Вывели адрес a
     cout<<"&x = "<<&x<<endl; //Вывели адрес x
    //Адреса a и x одинаковые


   x=888; //Изменили только переменную x
     cout<<"a = "<<a<<endl; //Вывели значение a (a=объект из адреса x (a=х),  x=888=>a=888)
     cout<<"x = "<<x<<endl; // Вывели значение x (x=888)
//Адреса а и x вы легко выведите самостоятельно и можете убедиться, что они не изменились.
   return;
  }
====================
 В приведенном коде показано почему говорят, что  ссылка - это второе имя. Вот есть некоторая обязательная переменная x, на которую ссылается ссылка. Если поменяли x, то поменялась и то что отображает ссылка, ссылающаяся на x.  Во время объявления ссылки а, x уже существует в природе, и в ссылку a записывается адрес, который был прописан компилятором для размещения значения x. Получается, что переменная-ссылка а, ссылаясь по адресу переменной x, обращается к тому значению, которое в этот x записано.

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

•   Ссылка не может ссылаться на несуществующий объект, указатель может
•   Ссылку нельзя переназначить

В первом вы легко убедитесь если уберете объявление переменной x.
Во втором вы убедитесь если попробуете присвоить ссылке значение другого адреса переменной
======================
 void main()
  {
 clrscr();
  int x,y;
  int &a=x; //a есть ссылка на x=> a это второе имя переменной x

   x=100;  cout<<a<<endl; //a=x=100;
   y=999; //Присвоили в y некоторое значение

   a=y; // Попытка связать ссылку a с адресом переменной y приводит к обычному присвоению

   cout<<x; // По адресу на который указывает a будет записано значение полученное в а (x=999)
  return;
  }
======================
  В предыдущем примере было изменено значение переменной, на которую ссылка ссылается и это отобразилось на результате вывода переменной-ссылки на экран. В этом примере произошла попытка связать ссылку с адресом переменной y, но вышло не то, чего стоило бы ожидать незнающему человеку. Вместо переназначения адреса, была произведена обычная операция присвоения. По адресу на который ссылка ссылается присвоенное в ссылку значение и было записано, следовательно было перезаписано значение x. (хотели а=адрес y, а получили значение x = значение y)
 В общем, смысл в том, что указателем можно тыкать в разные адреса, а ссылкой можно работать только по одному и тыкать ссылкой в другие адреса не получится


Подводя итоги сакцентирую внимание на самом важном

•  Ссылка - это второе имя переменной
•  Ссылка обязательно ссылается на адрес уже существующего значения
•  Во время объявление ссылки, ссылке обязательно присвоить значение на который ей придется ссылаться
•  Ссылка ссылается на адрес объекта, но работает с самим объектом по этому адресу
•  Ссылка обозначается знаком амперсанд (&)
•  Нельзя поменять тот адрес, который был присвоен ссылке во время её объявления
•  Обращение к ссылке происходит как обращение к обычной переменной
•  Всякое изменение ссылки преобразует не саму ссылку, а объект, на адрес которого ссылается ссылка
• Тип ссылки должен совпадать с типом объекта на адрес которого она ссылается
• Изменение объекта влияет на отображение ссылки, так как ссылка своего рода многократный инициализатор одной и той же переменной

void main()
{
  clrscr();
   int a;
   int &x=a; //Всё равно, что объявили вторую a, только назвали x 
  
   a=100; //Поменяли сам объект
   cout<<a<<"  = "<<x<<endl; //При таком обращении идет обращение к a
  
   x=777; //Ссылка ленивая сволочь, всю работу сваливает на объект. Происходит что-то вроде транзита. "Ссылка умыла руки" и вышло не (x=777), а (a=777)
   cout<<a<<" = "<<x<<endl; //обращаемся к объекту. (a=a=777). Задача ссылки только свалить всю работу на плечи объекта на который она по просьбе программиста ссылается
 getch();
 return;
}

Постоянная ссылка

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

 Для того чтоб понять этот пример нужно знать
  Функции в С++ для начинающих. Прототипы
  С++ для начинающих Конструктор Класса
  С++ для начинающих Определение методов класса вне класса

 Код C++ Передача параметра в конструктор
================================


class MyClass
 {
  int a; //В а будет передаваться значение из параметра 
  public:
    MyClass(int); //Прототип конструктора с одним параметром int 
    void show_a(); //Прототип функции show_a();
 }; //Закончили описание класса, обязательны точка с запятой

//Описываем методы класса MyClass вне класса
MyClass::MyClass(int N) //Конструктор принимает один параметр в N
 {
  a=N; //В a из MyClass присваивается значение равное N
 } 

MyClass::show_a() //show_a() есть метод класса MyClass
{
cout<<a; //Выводим a на экран
return;
}
// Все нужные методы уже описали

MyClass obj(int);
 //Обратите внимание, что строчкой выше, в объект obj1 передается параметр int, который мы собираемся передать в конструктор объекта obj1. Если надо передать в 2 объекта, то было бы MyClass obj1(int),obj2(int); и далее по аналогии. Количество параметров и Тип который я передал в объект, я взял из прототипа описанного в конструкторе. MyClass(int) -> obj(int)


void main()
{
 int a; //Переменная а действует только внутри main() 
 clrscr(); //Очищаем экран от всего ненужного
   cout<<"Wwedi a";
   cin>>a; //Присваиваем в a значение введенное с клавиатуры


 MyClass obj1=MyClass(a); //а Передается в конструктор класса MyClass в качестве параметра
 obj1.show_a(); //Открытый метод из класса MyClass отображает а из метода MyClass
getch();
 return;
}
================================
В этом примере а внутри main и a внутри класса совершенно разные переменные. При выполнении функции main сначала выполняется код из функции main(), который очищает экран, предлагает ввести a и присваивает значение в  a функции main. После идет обращение к объекту obj1 - С помощью строчки MyClass obj1=MyClass(a) в конструктор объекта obj1 передается параметр a. В конструкторе это значение как эстафету принимает переменная N   MyClass::MyClass(int N)  Внутри конструктора есть своя переменная a Это переменная из класса MyClass. (Переменная a Класса к переменной a из функции main совершенно никакого отношения не имеет. Это разные переменные, названные одним именем)
Когда срабатывает конструктор, в переменную а из класса MyClass присваивается значение из N. Таким образом N Передал полученную эстафетную палочку далее и по назначению вовнутрь класса


Эстафета:
  a функции ---> N конструктора
  N конструктора ---> a из класса
 (На финише a из класса=a из функции)

Не знаю как вышло описать, но очень надеюсь не запутал своими объяснениями

Постоянная ссылка

Определение методов вне класса

В двух предыдущих статьях (С++ для начинающих Классы Первое знакомство  и С++ для начинающих Конструктор Класса)  функции и конструктор определялись внутри класса.  Другими словами- "методы класса были расписаны внутри класса". Такой подход не всегда удобен, поэтому в C++ существует альтернативный вариант. В альтернативном варианте вовнутрь класса размещается прототип функции, а вне класса пишется сама функция. Чтобы было понятнее, пишу пример.

=========================

class MyClass
 {
  int a; //Переменная а доступна только внутри класса MyClass
  public:
    MyClass(); //Прототип конструктора 
    void show_a(); //Прототип функции show_a()
 } obj1; //obj1 - Переменная типа MyClass. Здесь описание класса закончено, обязательны точка с запятой 


//++++++++++++++++++++++++++++++++++++++++++
MyClass::MyClass() //Класс::Конструктор  Конструктор не возвращает никаких значений
 {
   cout<<"Wwedi a:   "; //В конструкторе выполняется ввод значения в а с клавиатуры
   cin>>a;
 }


void MyClass::show_a()  //Тип функции Класс::Функция. Описываем функцию show_a()
{
  cout<<a<<endl; //Функция выводит на экран значение a из  класса MyClass
}
//Описание методов вне класса закончено
 
void main()
{
 clrscr(); //Очистка экрана для очистки при первом запуске 
   cout<<obj1.show_a();
 getch(); //Ожидание нажатия Enter 
 clrscr(); //Так как объекты конструируются до входа в функцию main, делаем генеральную уборку с экрана непосредственно перед самым выходом
 return;
}
=========================
Теперь пора пояснить для тех кому очень нужно. Эта программа аналогична такой:
 cin>>a;
 cout<<a;

Только выполнена через класс с использованием конструктора. Так сделано потому что в моем представлении этот примитив вполне может дать понять принцип построения простых классов. Внутри класса описываются детали класса и прототипы методов. Были прописаны прототипы двух методов (Конструктор и функция show_a). Дальше эти методы были прописаны вне класса. Между плюсовыми комментариями как раз идет написание этих обоих методов. Разные классы могут использовать методы с одинаковыми именами, из-за этого в С++ при определении метода класса вне класса используют оператор глобального разрешения (::)
 Сначала был прописан конструктор. Конструктор есть особый метод и всегда имеет тоже имя, что у своего класса. Конструктор никогда не возвращает значений, даже void недопустим, поэтому в начале строчки Class::MyClass() отсутствует тип. При этом конструктор может принимать параметры (в скобки можно записывать).
 После описания конструктора была описана функция show_a(); Так как функция всегда возвращает значение, то вначале обязательно указывать возвращаемый тип. В примере этот тип void  (void show_a();)
 Сама конструкция определения методов вне классов
 };
Тип  ИмяКласса :: МетодКласса(Параметры) //Вначале тип метода класса
 {
   основной код метода
 }

Так как класс сам по себе бесполезен, для него был создан объект. Объект представляет из себя переменную - экземпляр класса. В примере это переменная obj1. В функции main через объект obj1 запускается конструктор класса MyClass, внутри конструктора прописано предложение ввести значение и это значение присваивается в a из класса MyClass. После того как объект был собран, выполняется сама функция main. Очищается экран, выполняется метод класса show_a. В этом методе прописано только одно действие - вывод a на экран. Потом происходит ожидание нажатия клавиши Enter, очистка экрана и выход из программы

Постоянная ссылка

• Конструктор автоматически вызывается при создании объекта (создании экземпляра класса)

•  Конструктор никогда не возвращает значение

•  Объекты конструируются до входа в функцию main()

• Один из способов объявления конструктора - это внутри класса в разделе public (Это было использовано в примере) (кроме этого есть другие способы объявления конструктора)

Постоянная ссылка

С++ для начинающих Классы

  Введение в ООП всегда вызывает затруднение у большинства студентов.

 В стандарте C++ под классом (class) подразумевается пользовательский тип, объявленный с использованием одного из ключевых слов class, struct или union, под структурой (structure) подразумевается класс, определённый через ключевое слово struct, и под объединением (union) подразумевается класс, определённый через ключевое слово union.

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

Задача: Сложить два числа через классы в C++

Код C++ Пустая программа
==========================
void main()
{
  return;
}
==========================


Код C++ Объявление класса
==========================
class summa  //Объявили класс summa (Тут не нужны скобки).
{

}; //Обратите внимание на точку с запятой


void main()
{
  return;
}

==========================


Этап третий. Подготавливаем класс описывая внутри всё для работы
Код C++ Подготовка класса
==========================
class summa  //Объявили класс summa (Тут не нужны скобки).
{
  int x,y;  // по умолчанию private 
  public:    //После слова public ставим двоеточие
   void get_xy()  //Функция доступна из любого места программы. Вводим через функцию 2 числа
     {
       cout<<"Wwedi X:  ";

       cin>>x; //Ввели X
       cout<<"Wwedi Y:  ";
       cin>>y; //Ввели Y
     }
  int sum_xy() //Функция суммирования двух чисел
   {
     return x+y; //X,Y берутся из класса
   }
}; //Обратите внимание на точку с запятой 

void main()
{
  return;
}
==========================



Код C++ Работа с классом
==========================


class summa  //Объявили класс summa (Тут не нужны скобки).
{
  int x,y;  // по умолчанию private 
  public:    //После слова public ставим двоеточие
   void get_xy()  //Функция доступна из любого места программы. Вводим через функцию 2 числа
     {
       cout<<"Wwedi X:  ";
       cin>>x; //Ввели X
       cout<<"Wwedi Y:  ";
       cin>>y; //Ввели Y
     }
  int sum_xy()  //Функция суммирования двух чисел
   {
     return x+y; //X,Y берутся из класса.
   }
} s1; //Обратите внимание на точку с запятой. s1 - это объект класса summa.


void main()
{
  s1.get_xy();  //Обращаемся к объекту класса и через него вызываем функцию ввода данных
  cout<<s1.sum_xy();  //Обращаемся к объекту класса и через него вызываем функцию, в которой суммировали X+Y
  return;
}
========================== 

Теперь я подробнее расскажу про важные моменты в этом коде
 1) Что такое класс и вообще зачем он нужен?

В первую очередь класс является собственным типом данных.
Класс - это некоторая идея еще не существующего объекта, в которой воедино собраны все детали, все свойства и все нужные действия необходимые для этого объекта
Проведу небольшую аналогию с типами данных. Когда вы определяете какие переменные вам нужны, вы их прописываете в объявлении переменных определяя им тип. При этом самих переменных еще нет, но вы их уже задумали. 
 void main()
 {
   int    //Вы еще не прописали переменной, но она задумана и тип уже прописан.

  return;
 }

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

После создания пустого класса внутри этого класса прописывается вся информация для выполнения поставленной задачи. Важные моменты то, что внутри класса используются слова public, private и protected. Я заострю внимание на public  и private
 Это модификаторы доступа. То что описано внутри public доступно для всей программы, а то что написано внутри private доступно только внутри класса. Чем-то очень похоже на локальные и глобальные переменные. Модификатор доступа в классе по умолчанию private, поэтому слово private: писать не обязательно. Ниже написаны две равнозначные записи
 class summa           class summa
 {                            {
private:                     int x,y,z;
  int x,y,z;                  public:
public:                        int a;
  int a;                       };
 };

Главный вопрос в том что, что прописывать в private, а что в public. Я если честно не знаю. Можно много спорить. Но попробую описать. В private стоит прописывать все детали вашей конструкции, в public только те функции и те данные, доступ к которым должен как-то происходить из функций вне класса.
 В приведенном примере на третьем этапе было определено так, что к деталям я отнес переменные x,y и к ним доступа кроме как внутри класса не дал, прописав их внутри private (по умолчанию private). Вместе с этим мне потребовались две отдельные функции. Первая функция ввод чисел, Вторая функция складывает числа. Как ни крути, логично, что доступ к этим функциям мне нужен извне класса, поэтому я сделал обе функции доступными для всей программы и доступ к ним могу получить практически в любом месте программы вне класса.

Так как класс всего-лишь идея, то надо её перевоплотить в жизнь. Чтобы это сделать нужно объявить объект. Объект это экземпляр класса.
 Если у вас есть класс, но нет объекта, то вы как депутат голословный пустословите и обещаете, но на практике дел не делаете. Чтобы не быть "пустословом" обязательно создать объект, т.к. работать вы будете через этот объект. На четвертом этапе приведен пример создания объекта

По сути класс есть структура. Отличается класс от структуры только модификатором доступа по умолчанию. Чтобы обратиться к элементу внутри класса нужно прописать объект и через точку тот элемент к которому обращаемся. Можно обращаться только к тем элементам класса, которые описаны внутри public:
 На четвертом этапе, кроме создания объекта (экземпляр класса), я обратился к функциям вовнутрь класса summa через созданный объект. Так как я сделал доступными для всей программы две функции, то доступ к ним затруднений не вызывает.
 Первая функция - ввод данных. При вводе данных я вывожу на экран нужную информацию и считываю с клавиатуры два числа. Эти числа запоминаются в переменных X,Y внутри класса. Напоминаю, что непосредственного доступа к этим X,Y из программы у меня нет. Функция внутри класса выступает в роли посредника
 Вторая функция - сложение двух чисел. Вы прекрасно видите, что никаких параметров и ничего в функцию я не передавал. Просто обратился к переменным X,Y и просто их просуммировал. Во время ввода данных введенные значения присвоились в переменные X,Y вовнутрь private. После этого присвоения я могу работать с этими X,Y почти как с глобальными переменными, разница от глобальных в том, что могу только в классе


Еще один момент о котором я бы решил не отмалчиваться. В приведенном примере getch() и clrscr() надеюсь сможете поставить. (просто чтоб не отвлекать внимание не писал этих строчек). Я использовал немного разное написание функций. Я писал void main() и void get_xy() - просто эти функции мне ничего не должны считать и значит возвращать значений не обязаны, а вот сумма чисел обязана вернуть какое-то значение, так как произошло вычисление. В приведенном примере она возвращает сумму двух чисел, поэтому  int sum_xy().


Подвожу итоги

• Класс есть структура, в которой доступ по умолчанию private

•  Класс - это собственный тип данных

•  Класс - это некоторая идея еще не существующего объекта, в которой воедино собраны все детали, все свойства и все нужные действия необходимые для этого объекта 

• Создается класс с помощью слова class    (struct,union)

Постоянная ссылка