Указатели в C++ для начинающих обычно очень непонятны. Связано это с двойственностью природы указателей. Указатель - это переменная, которая хранит адрес памяти.
 В статье Указатели в C++ для начинающих. Поверхностное знакомство было описано очень мало, но что такое указатели знать нужно и надо иметь представление как с ними работать.

 int *x;  //переменная x есть указатель на int;

так как указатель хранит адрес памяти, то попытка обращения к указателю вернет этот адрес
 cout<<x; //На экран выводится какой-то адрес памяти

cout<<*x; //звездочка - это оператор разыменования
*x=100;   / звездочка - это оператор разыменования
/В этом примере сначала на экран выведется какое-то любое значение, после чего  по адресу памяти на который указывает x будет записано число 100. Так как в обоих случаях было применено разыменование, то будут выведены именно значения, а не адреса памяти.



 Код C++ Указатель + Разыменованный указатель
==================

int x=20; //Переменная x = 20
int *ptr; //ptr есть указатель на int

void main()
{
 clrscr();
//Выводим на экран различные значения 
   cout<<"ptr = "<<ptr<<endl; //Указатель ptr = Адрес памяти 
  cout<<"*ptr"<<*ptr<<endl; //Разыменованный указатель ptr = Значение по адресу   
 getch();
 return;
}
 ==================
Будьте внимательны в приведенном коде, где была операция разыменования, стоит звездочка. В первый раз было обращение непосредственно к указателю,  а так как указатель есть переменная, хранящая адрес памяти, то именно с этим адресом памяти и работает программа при прямом обращении к указателю, поэтому и был выведен некоторый адрес памяти вместо значения. Во второй раз при обращении к указателю была поставлена звездочка. Такое обращение к указателю называется разыменование и указатель обращается к объекту на который ссылается. На экран было выведено значение, а не адрес памяти


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

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


 В C++ у любой переменной, в том числе и не указателя можно узнать адрес памяти, по которому она расположена. Делается это с помощью оператора &

 Код C++ Взять адрес у переменной. Ссылка
=============================

void main();
{
 int a=10; //любая переменная
  cout<<" a = "<<a<<endl; //Обратились к a (значение=10)
  cout<<"adres a = "<<&a<<endl; //Взяли адрес переменной а (что то такое 0*fff4)
 getch();
 return;
}
=============================

Так вот, после объявления указатель не связан с конкретным значением и указывает пальцем в небо. Для того, чтоб его связать с каким-то объектом используется оператор &. Вы уже знаете, что оператор & обозначает взятие памяти у переменной. А так как указатель есть адрес памяти, то и работает он с адресами памяти.
 Следовательно, чтобы связать указатель с каким-то значением, нужно обратиться к адресу нужного значения. Надеюсь логика проста и понятна.

Код C++. Связать указатель с переменной
=============================

void main()
{
  clrscr();
    int *ptr; //ptr есть указатель на int
    int a=100; //a является обычной переменной 

    cout<<"*ptr = "<<*ptr<<endl; //Чтобы получить значение ptr - разыменовали указатель ptr
      //так как указатель не был связан ни с какими значениями, можно получить что угодно 
    ptr=&a;// Взяли адрес у переменной a и присвоили этот адрес в указатель
    cout<<"*ptr = "<<*ptr<<endl; //Указатель теперь указывает на a. Значит *ptr = a = 100
    

 getch();
 return;
}
=============================



        Очень важный момент
    Если указатель указывает на некоторый один адрес памяти, то и работает он со значением из этого адреса. 
 а) Изменяя значение переменной по адресу на который указатель указывает - изменится и значение разыменовываемого указателя
 б) При присвоении значений разыменованному указателю - изменится значение переменной по указываемому указателем адресу 
 Код C++ двойственность природы указателей
================================

void main()
{
 clrscr();
   int a,b; //Разные переменные
   int *ptr; //ptr есть указатель на int
  
  //Вариант а. Изменение значения переменной для указателя 
   ptr=&a; //Указатель ptr = адрес переменной a
   a=100;  //присвоили любое значение в переменную на адрес которой указатель указывает
   cout<<"a = "<<*ptr<<endl; //т.к. указатель опирается на адрес переменной a, любое изменение a влияет на то, что отображает разыменованный указатель. *ptr=a=100
   a=999; //поменяли значение переменной
   cout<<"a = "<<*ptr<<endl; //указатель опирается на адрес переменной a. *ptr=a=999



//Вариант б. Изменение разыменованного указателя влияет на переменную по адресу указателя
  a=100; //чтоб было понятнее. изменим a на новое значение
  с=55;   //вторая переменная
 
  ptr=&a; //Указатель = адрес переменной a => *ptr=a=100;
 *ptr=999; //По адресу переменной а записалось новое значение. a=*ptr=999;

  ptr=&c; //Указатель теперь указывает на адрес с. Влияние указателя на а прекращено 
  *ptr=88; //с изменилось было 55 - стало 88 

cout<<"a = "<<a<<endl; //a=100 a=999
cout<<"c = "<<c<<endl; //c=55  c=88
 getch();
 return;
}
================================
 Двойственность природы указателей причина многих недопониманий и ошибок. Понять для начинающих очень непросто, но понять можно. А вот, чтобы с ними дружить надо понимать природу указателей и как с ними работать на превосходное отлично.

 Подводя итоги я повторюсь и напишу самое главное из этой статьи про указатели.

• Указатель - это вид переменной, которая хранит адрес в памяти
• Объявляется указатель с помощью звездочки
• Чтобы обратиться к значению по адресу указателя используется разыменование
• У любой переменной можно взять адрес памяти. Для этого используется символ &
• Так как указатель есть адрес памяти, то ему можно присвоить адрес памяти от любой переменной
• У указателя двойственная природа. Можно обрабатывать адрес памяти, а можно значение внутри этого адреса.

Понять сложно, но можно. самое главное старайтесь понять, а не заучить

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

Символьные строки C++ Вывести алфавит с помощью цикла for

Для объявления символьной строки объявляется массив типа char с количеством переменных, достаточным для хранения требуемых символов
 char S[64] - Объявили символьную строку, которая хранит 64 символа. (64 символ - это символ NULL (признак окончания строки))

 Для приведенного ниже примера, нужно, чтоб ваш компилятор корректно работал с русской кодировкой и правильно отображал русские символы.

 Код C++ Русский алфавит с помощью цикла for
====================

void main()
{
  char alphabet[34]; // Объявили массив символов в 33 символа (34 символ = NULL)
  char letter; //считываемый символ
  int index=0; //счетчик. сразу ставим его в ноль 

  for (letter='А';letter<='Я'; letter++) //От символа А, до символа Я выполняется цикл for
    { 
/*С каждым проходом цикла символ letter меняется на следующий за ним символ. В условии цикла прописано, чтоб цикл проходил по порядку од одного символа до другого */

     alphabet[index]=letter; //В массив по индексу index записывается символ , хранящийся в letter
     index++; //После каждого прохода цикла увеличиваем индекс массива, чтоб записать следущее значение в новый элемент массива
    }

   alphabet[index]=NULL; //Записываем в последний элемент массива признак конца строки

cout<<"Буквы:  "<<alphabet; //Выводим строки по порядку на экран
getch();
return;
}
====================

Для тех кому по пальцам 
 Для начинающих скорее всего придется уточнить момент. Во время выполнения цикла каждый раз увеличивалась переменная index В этой программе переменная index обозначает номер элемента массива. Чтобы не затереть значение в текущем элементе массива, программист записывает данные в другие элементы данного массива. Чтобы не возникло путаницы - программист обращается ко всем элементам поочередно. При первом проходе цикла letter ="А", при втором letter ="Б",... и так пока не выполнится условие цикла for-. Каждый раз letter меняет значение и каждый раз после этого записывается в текущий элемент массива, затем считывается следующий символ и увеличивается индекс массива.  После того как условие цикла for выполнится - запишется последний элемент массива, произойдет еще одно увеличение счетчика индексов и цикл на этом завершится.
 После окончания работы цикла - в элемент массива по индексу счетчика [index] , будет записан признак конца строки.

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

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

 В качестве обучающего примера попробую описать область видимости переменных с помощью функций.

Первый вариант - глобальная переменная. Глобальная переменная объявляется один раз и действует по всей программе.

Код C++ Глобальная переменная
=======================

void main(); //Прототип функции main
void sum(); //Прототип функции sum

//Обратите внимание, что переменные объявляются вне функций
  int i=100; //Глобальная переменная i. При объявлении запоминаем в i некоторое значение
  int a; //Глобальная переменная a

 void main()
{
  clrscr();
  a=200;//так как a была объявлена вне функции - она глобальная и значит доступна по всему коду
  sum(); //Вызываем некоторую функцию
  return;
}

void sum()
{
 cout<<i<<endl; //Выводим значение переменной i на экран = 100
 cout<<a<<endl; //Выводим значение переменной a на экран = 200. Значение 200 было записано в main 
 cout<<i+a<<endl; //Выводим значение i+a на экран = 300
 getch();
 return;
}
=======================
 Глобальная переменная объявляется вне тела функций и доступна она до конца программы.  В приведенном примере вне функций было объявлено две переменные. К каждой из них можно обратиться в любом блоке программы. При этом последнее запомненное значение таких переменных остается в памяти и доступно для последующей обработки.
  Смысл этого можно понять, посмотрев приведенный пример. Персонально для функции sum переменных создано не было, но несмотря на это я смог с помощью sum вывести верные значения переменных на экран. Смог потому что объявил их вне тел функций, а значит сделал глобальными, т.е доступными для любой другой функции (любого другого блока программы).



Если я плохо объяснил, что обозначает глобальная переменная, то я неудачник. Если хорошо, то имеет смысл читать дальнейшее описание. Помимо понятия Глобальная переменная - существует Локальная переменная. Локальная переменная определяется внутри функции и доступна она только для функции, внутри которой была объявлена.
Код C++ Локальная переменная
=======================
void main(); //Прототип функции main
void sum(); //Прототип функции sum

  void main()
{
  int a; //Объявили переменную внутри main, т.е. объявили локально
  a=200; //Переменная объявленная внутри main доступна только и только внутри  main
  return;
}

void sum()
{
 int i; //Объявили переменную i внутри sum. Другими словами объявили локальную переменную i
 cout<<i<<endl; //Выводим на экран i
 cout<<a<<endl; //Тут должна быть ошибка
 cout<<i+a<<endl;
 getch();
 return;
}
 Ошибка в указанном месте возникает из-за того, что для функции sum не действует никакая переменная, объявленная внутри любой другой функции. Если программист объявляет переменную внутри некоторой одной функции, значит он предполагает, что с этой переменной будет работать только и только та функция, в которой переменная была объявлена. Такие переменные живут только внутри своих функций и не доступны для других участков кода. Это и есть локальная переменная. В отличии от первого приведенного примера, в этом примере глобальных переменных объявлено не было. Значит по факту для sum переменной a не существует в природе.



Существует ситуация, когда программист объявляет глобальную и локальную переменные с одинаковыми именами. В этом случае во время работы функции с локальной переменной локальная переменная закрывает глобальную и говорит: "Я тут главная". Непосредственная работа выполняется с локальной переменной, при этом значение глобальной переменной остается в памяти
 Код C++ Локальная переменная затеняет глобальную
=======================
void main(); //Прототип функции main
void sum(); //Прототип функции sum
void new_fun();  //Прототип функции new_fun

  int i=100; //Глобальная переменная i

  void main()
{
  cout<<i<<endl; //В этом случае i глобальная, т.к. внутри main i объявлено не было i=100; 
  sum(); //Вызывам некоторую функцию
  new_fun(); //Вызываем некоторую функцию
  getch();
  return;
}

void sum()
{
 int i=20; //Переменная i локальная т.к. объявлена внутри sum. Действует только внутри sum 
 cout<<i<<endl; //Выводим на экран i. Локальная i затенила глобальную (действующая i=20). Глобальная i висит в памяти 

 return;
}

void new_fun() //Внутри new_fun переменных не объявлено, значит для new_fun существуют только глобальные переменные
{
 cout<<i<<endl; //Выводм на экран глобальную i (i=100)
return;
}
=======================
В случае когда программист объявляет глобальную переменную и одноименную с ней локальную, локальная затеняет глобальную. При вызове функции с локальными переменными, локальные переменные по приоритету выше глобальных. Так как локальные переменные  по приоритету выше, значит значения для вычислений берутся из них. По завершении функции глобальная переменная вновь приобретает силу. Это можно понять по приведенному примеру. Вне функций была объявлена некоторая переменная i (вне = глобальная), вместе с ней внутри функции sum была объявлена еще одна переменная i (внутри = локальная).



 В последнем примере было описано, что обозначает выражение "локальная переменная затеняет глобальную". Так как глобальная переменная не теряет своего значения, то программист может обратиться непосредственно к ней внутри функции с одноименной локальной переменной . Для такого обращения используется глобальный оператор разрешения
Код C++ Глобальный оператор разрешения
=======================

int i=100; //Глобальная переменная i

void main()
{
  clrscr();
  int i=50; //Локальная переменная i
  cout<<i<<endl; //Обращение к локальной переменной (i=50)
  cout<<::i<<endl; //Обращение к глобальной переменной (i=100) Использован глобальный оператор разрешения

  getch();
 return;
}
=======================
 Такое описание было написано для тех начинающих, которым надо всё поподробнее растолковать. Самое главное запомнить понятие локальной и глобальной переменных

•  Локальная переменная - такая переменная, которая объявляется внутри функции и действует она только внутри своей функции (видима только своей функции)
•  Глобальная переменная - такая переменная, которая объявлена вне функции и доступна она для окончания работы программы (видима всей программе)

 Несмотря на описанные возможности не рекомендуется применять переменные с одинаковыми именами. Во избежание путаницы следует избегать глобальных переменных везде где возможно. Это важно помнить.

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

 В С++ существует понятие Перегрузка функций. Благодаря возможностям языка функции не обязательно должны объявляться с  уникальным именем. В качестве классического примера приводится создание функций для некоторого однотипного вычисления при различных типах данных.

 Говоря конкретнее и понятнее для начинающих.
 Надо создать две функции сложения. Первая функция будет складывать целочисленные значения типа int, вторая функция будет складывать дробные значения типа float.

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

 Код С++ Вариант 1 (a+b). Уникальные имена функций
=========================
int sum_int(int a, int b)  // Функция sum_int
{
 return a+b;
}


float sum_float(float a, float b) //Функция sum_float
{
 return a+b;
}
===========================


   Код С++ Вариант 2 (a+b). Перегрузка функций 
===========================
int sum(int a, int b)  //Функция sum
{
 return a+b;
}


float sum(float a, float b) //Функция sum
{
 return a+b;
}

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

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

 Количество параметров в случаях перегрузки функции у функции может быть разным.


 Код С++ Вариант 3 (a+b). Перегрузка функций Число параметров разное
===========================
int sum(int a, int b)  //Функция sum с двумя параметрами
{
 return a+b;
}


float sum(int a, int b, float c) //Функция sum c тремя параметрами
{
 c=1/a+a/b; //Суммирование некоторых значений
 return c*3; //Возвращаем сумму некоторых вычисленных значений умноженную на 3
}
===========================

 При правильном подходе в разработке больших проектов использование перегрузки функции может сэкономить значительное время.

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

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

Структуры в С++ есть совокупность переменных, объединенных под одним именем.

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

 чтобы было понятнее приведу пример объявления структуры

Код С++ структуры Объявление структуры
=================================
struct TPoint //Объявили новую структуру TPoint.
{
  int x; //Первый параметр
  int y; //Второй параметр
}; //После описания структуры ставят точку с запятой


void main()
{
 TPaint O; //Объявили переменную O типа TPoint
}
=================================
Так описывается структура в коде программы. Стоит обратить внимание, что при объявлении структуры нету круглых скобок  struct TPoint  ()  а после закрывающейся фигурной скобки стоит точка с запятой. Параметров внутри структуры может быть сколько угодно и типы у них могут быть разные.


.
Код С++ структуры Обращение к структуре
=================================
#include <conio.h>
#include <iostream.h>
struct TPoint //Объявили новую структуру TPoint.
{
  int x; //Первый параметр
  int y; //Второй параметр
}; //После описания структуры ставят точку с запятой

void main()
{
 clrscr();
 TPaint O; //Объявили переменную O типа TPoint
      O.x=30; //Присвоили первому параметру значение
      O.y=100; //Присвоили второму параметру значение
getch();
}
=================================
 В этом коде была объявлена переменная O тип данных которой соответствует структуре TPoint
У структуры TPoint было объявлено 2 параметра. (x,y). При обращении к O программист должен обратиться к определенному параметру из струтуры к которой О относится. Такое обращение происходит через точку


Чтобы создать вторую переменную с двумя параметрами, но отличающуюся от первой достаточно прописать
 TPoint O,А; //Объявили переменные O и A типа TPoint
Код С++ структуры
=================================
#include <conio.h>
#include <iostream.h>
struct TPoint //Объявили новую структуру TPoint.
{
  int x; //Первый параметр
  int y; //Второй параметр
}; //После описания структуры ставят точку с запятой

void main()
{
 clrscr();
 TPoint O, A; //Объявили переменные типа TPoint 
      O.x=30; //Присвоили первому параметру значение
      O.y=100; //Присвоили второму параметру значение

      A.x=130; //Присвоили первому параметру значение
      A.y=10; //Присвоили второму параметру значение
getch();
}
=================================

Теперь в памяти хранятся 2 сгруппированные переменные типа TPoint. Каждой переменной соответствует по 2 параметра типа int

 Теперь с элементами A.x,A.y,O.x,O.y можно работать как с обычными переменными int. Просто в примере был показан способ создания своего типа данных, в котором в одной перменной сгруппировано две. (В переменной O - две переменных типа int и в переменной А две переменных типа int)

 Данные, которые хранятся в одной структуре могут быть присвоены другой структуре если обе структуры хранят одинаковые параметры.
 Можно сказать, что в предыдущей программе было объявлено две структуры Структура А и структура О.


Код С++ структуры
=================================
#include <conio.h>
#include <iostream.h>
struct TPoint //Объявили новую структуру TPoint.
{
  int x; //Первый параметр
  int y; //Второй параметр
}; //После описания структуры ставят точку с запятой

void main()
{
 clrscr();
 TPoint O, A; //Объявили переменные типа TPoint 
      O.x=30; //Присвоили первому параметру значение
      O.y=100; //Присвоили второму параметру значение

      A=O;  //теперь A.x=O.x=30, A.y=O.y=100;


//Выводим на экран структуры О и А

cout<<A.x<<endl;
cout<<A.y<<endl;
cout<<O.x<<endl;
cout<<O.y<<endl;
getch();
}

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

 Внимание. чтобы вывести структуру на экран, нужно прописывать ее элементы. Если попробовать вывести структуру
 cout<<A<<endl;
 Будет сообщено об ошибке.

 Поэтому для начинающих важно помнить. При попытке доступа к струтуре нужно обращаться непосредственно к элементу вовнутрь структуры, а не к структуре как к целому. Исключение только тогда - когда струкуры надо сравнять ( например как в последнем примере). Чтобы обратиться к отдельному элементу структуры нужно прописать этот элемент через точку.

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