Массивы: Если размер массива неизвестен

#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
    int Size = 100 ; // пусть нам надо 100 ячеек памяти
    char *My_Arr = new char [Size] ; // создадим указатель на массив типа char
    //  и запросим у операционной системы подряд Size ячеек памяти типа char для нашего массива
    // массив готов к использованию
    // посмотрим, например, что хранилось в этих ячейках памяти до нас
    for (int i = 0 ; i < Size ; i = i + 1 )
    {
    std::cout << My_Arr[i] << " " ; // напечатаем каждый элемент массива через пробел
    }
    std::cout << "||" << std::endl ; // закончим печать двумя черточками и перейдем на новую строку
    delete [] My_Arr ; // нам больше не нужна эта память, поэтому вернем её операционной системе
                        // теперь мы не знаем, что будет там храниться, т.к. это уже не наша память
    Sleep (10000) ; // подождем 10сек, чтобы окно не сразу закрылось
return 0 ;
}

    int n = 10;
    //... здесь, значение n, во время работы программы, может измениться
    const int N = n; // N - неконстантное выражение
    int arr[N]; // ошибка

    const int N = 10; // N - константное выражение
    //... значение N, во время работы программы, не может измениться
    int arr[N]; // Ok

void foo(){
   int arr[5] = {0} ;
   /*
   Это массив. 
   Расположен он будет на стеке функции
   Его размер должен быть известен во время компиляции.
   Если размер неизвестен, то можно воспользоваться следующими вариантами:
   1) Зарезервировать места сразу под большое число элементов, но это приведет либо 
       к большому перерасходу памяти, а ведь стек не резиновый, либо 
       к жесткому ограничению кол-ва элементов, которые можно в этот массив положить
   2) Можно при необходимости запрашивать динамической памяти рюмочку, ну или стаканчик,
       но порой приходится целую бочку памяти просить.
       Причем придется руками следить за выделением/освобождением (без RAII), 
       копированием элементов в новую память, размерами и т.д.
   3) Можно использовать готовые обертки, например, std::vector,
       которые, при правильном использовании берут часть головной боли на себя,
       подставляя под удар своё страшное и хрупкое шаблонное тельце.
   4) Забыть и никогда не вспоминать о c++.
   */
}

#include <iostream>
#include <cstdlib>
 
 
 
struct Test
{
    Test() { std::cout << "ctor. address: " << this << std::endl; }
    Test(const Test& src) { std::cout << "cctor. address: " << this << "; source address: " << &src << std::endl; }
    Test& operator=(const Test& src) { std::cout << "assign. address: " << this << "; source address: " << &src << std::endl; return *this; }
    ~Test() { std::cout << "dtor. address: " << this << std::endl; }
    double x;//Не будем его использовать, просто чтобы место занимало
};
 
 
 
int main()
{
    size_t count = 0 ;
    std::cout << "input count-> " ;
    std::cout.flush();
    std::cin >> count ;
    if(count==0){
        std::cerr << "\nerror: invalid count\n";
        return -1;
    }
    //////////////////////////////////////////////
    std::cout << "\nTest malloc for " << count << " elements:\n" ;
    //выделяем память в количестве, достаточном для хранения введенного числа элементов
    Test * test_ptr = (Test*)malloc(sizeof(Test)*count);//Требуется явный каст к Test*, т.к. в c++ запрещен неявный каст от void*.
    std::cout << "memory address: " << test_ptr << std::endl;
    //освобождаем память:
    free(test_ptr);
    //////////////////////////////////////////////
    test_ptr = nullptr;//возьмите за правило обнулять указатели, которые больше не валидны.
    std::cout << "end of main" << std::endl;
}

    //////////////////////////////////////////////
    std::cout << "\nTest new:\n" ;
    //выделяем память в количестве, достаточном для хранения одного элемента
    Test * test_ptr = new Test();
    std::cout << "memory address: " << test_ptr << std::endl;
    //освобождаем память:
    delete test_ptr;//Выделялось с помощью new, поэтому здесь delete
    test_ptr = nullptr;
    std::cout << "\nTest new[] for " << count << " elements:\n" ;
    //выделяем память в количестве, достаточном для хранения введенного числа элемента
    test_ptr = new Test[count];//Указываем уже не число байт, а количество элементов
    std::cout << "memory address: " << test_ptr << std::endl;
    //освобождаем память:
    delete[] test_ptr;//Выделялось с помощью new[], поэтому здесь delete[]
    //////////////////////////////////////////////

int main()
{
    std::cout << "\nTest reallocate memory:\n" ;
    //Значения могут быть вычеслены в рантайме, но чтобын е городить огород я задам их прямо в коде
    //Выделяем память в количестве, достаточном для хранения трех элементов
    Test * test_ptr = new Test[3];
    std::cout << "memory address: " << test_ptr << std::endl;
 
    //А теперь нам вдруг потребовалось "расширить" этот "массив" еще на один элемент.
    //Необходимо выделить память под 4 элемента:
    Test * test_ptr_temp = new Test[4];
    //И скопировать в новую память старые элементы:
    for(size_t i = 0 ; i < 3; ++i){
        test_ptr_temp[i] = test_ptr[i];
    }
    //Теперь, память, занимаемая массивом из трех элементов нам более не нужна.
    //Освобождаем её:
    delete[] test_ptr;//Выделялось с помощью new[], поэтому здесь delete[]
    test_ptr = test_ptr_temp; //Всё, теперь у нас по адресу, который содержится в test_ptr лежит 4 элемента
    test_ptr_temp = nullptr;
    //Поработали
    std::cout << "big work" << std::endl;
    //Теперь освобождаем память:
    delete[] test_ptr;//Выделялось с помощью new[], поэтому здесь delete[]
    test_ptr = nullptr;
    std::cout << "end of main" << std::endl;
}