Pointers (1)

#include "pch.h"
#include <iostream>
using namespace std;

void func();

int main()
{

    // 1. Разница между типизированными и нетипизированными указателями.
    cout << "1. " << endl;

    int b = 5;
    void * ptr_2 = &b; // ptr_2 указывает на область памяти, где хранится b
    cout << "Нетипизированный указатель указывает на область памяти : " << ptr_2 << endl; // область в памяти
    int * ptr_3 = (int*)ptr_2; // чтобы получить значение
    cout << "А если указатель нетипизированный, можно вывести значение, на которое он ссылается : " << *ptr_3 << endl;
    // Нетипизированный указатель может только указывать на область памяти, где хранится переменная
    // Но вывести значение не получится
    cout << endl << endl;


    // 2. Разница между указателями на данные и на функции
    cout << "2. " << endl;

    void(*point)(); // Указатель на функцию (процедуру)
    point = func; // теперь он определен
    point(); // вызываем == выполняем функцию func();
    // ну а примеры указателей на данные были выше
    cout << endl << endl;


    // 3. Разница между указателем и указуемым объектом;
    cout << "3. " << endl;

    int a3 = 5; // указуемый объект
    int *aPointer; // указатель
    aPointer = &a3; // теперь он указывает на объект
    cout << endl << endl;

    // 4. Разница между указателями-константами и указателями на константу
    cout << "4. " << endl;

    int a4 = 5; // теперь в определенной области памяти лежит значение 5
    // изменить область памяти нельзя
    a4 = 6; // можем изменить значение, поэтому это пример указателя-константы.

    const int a41 = 5; // константа. теперь в определенной этой области памяти лежит значение 5
    // и мы не пожем поменять ни значние переменной, ни область памяти
    const int *b4; // указатель. пока он никуда не ссылается
    b4 = &a41; // а теперь он ссылается на константу, то есть он является указателем на константу
    cout << endl << endl;


    // 5. Особенности работы с многоуровневыми указателями;
    cout << "5. " << endl;

    int a5 = 4;
    int *b5 = &a5; // Указатель указывает на область памяти ячейки a5;
    int **c5 = &b5; // указывает на область памяти b5, то есть на указатель b5

    cout << a5 << " " << *b5 << " " << **c5 << endl; // ну и это одно и то же, как и ожидалось
    cout << endl << endl;



    // 6. Разница между указателями и ссылками.
    cout << "6. " << endl;

    int *a6; // указатель
    int b6 = 5;
    cout << &b6 << endl; // ссылка на адрес, по которому находится объект b6

    // Указатели можно переопределить:
    int c6 = 4;
    a6 = &b6;
    cout << *a6 << endl; // выведет 5
    a6 = &c6;
    cout << *a6 << endl; // выведет 4
    // А вот ссылки переопределить нельзя: &c6 = &b6 - неправильно

    // Ссылка не может быть null.
    // по той причине, что ссылка появляется, когда мы определяем переменную
    int a61; // Переменная = null, в ссылка на нее уже имеется
    cout << &a61 << endl; // выведет ячейку в памяти, где хранится эта переменная
    cout << a61 << endl; // выведет непонятно что, так как мы не задали значние переменной

    // А вот указатель может быть null
    int *b61; // Он никуда не ссылается => null
    // ну а вывести его не получится, так как он не инициализирован


}

void func() {
    cout << "Here is just a function" << endl;
}