Interactive work with an array

#include <cctype>
#include <iomanip>
#include <iostream>
#include <random>
#include <string>

using namespace std;

void flush(istream& inp = cin) {
    inp.ignore(0x1000, '\n');
}

double double_parse(const string& msg = "") {
    string word;
    double value{};
    while (true) {
        cout << msg;
        cin >> word;
        flush();
        try {
            value = stod(word);
            return value;
        } catch (invalid_argument& e) {
            cin.clear();
        } catch (out_of_range& e) {}
    }
}

size_t size_t_parse(const char* msg = "") {
    string word;
    size_t value{};
    while (true) {
        cout << msg;
        cin >> word;
        flush();
        try {
            if (sizeof(size_t) == 4) value = stoul(word);
            else value = stoull(word);
            return value;
        } catch (invalid_argument& e) {
            cin.clear();
        } catch (out_of_range& e) {}
    }
}

enum class Menu {
    Average = 0x61,
    Create  = 0x63,
    Fill    = 0x66,
    Exit    = 0x65,
    Random  = 0x72,
    Sum     = 0x73
};

Menu point() {
    char ch;
    cin >> ch;
    cin.ignore(0x1000, '\n');
    return Menu(tolower(ch));
}

double* create(const size_t n) {
    return new(nothrow) double[n];
}

double* destroy(double* vec) {
    if (vec != nullptr) {
        delete[] vec;
        vec = nullptr;
    }
    return vec;
}

bool fill(double* vec, const size_t n) {
    puts("Input array:");
    for (size_t i = 0; i < n; ++i) {
        vec[i] = double_parse("[" + to_string(i) + "] => ");
    }
    return true;
}

bool rand(double* vec, const size_t n) {
    uniform_int_distribution<> uid(-99, 99);
    mt19937 gen{ random_device()() };
    cout.setf(ios::fixed);
    cout.precision(1);
    for (size_t i = 0; i < n; ++i) {
        vec[i] = uid(gen) / 10.0;
        cout << setw(8) << vec[i];
    }
    puts("");
    cout.unsetf(ios::fixed);
    cout.precision(8);
    return true;
}

void average(double* vec, const size_t n) {
    auto sum = 0.0;
    size_t cnt = 0;
    for (size_t i = 0; i < n; ++i) {
        if (vec[i] > 0) {
            sum += vec[i];
            ++cnt;
        }
    }
    cout << "Average: " << (cnt ? sum / cnt : 0) << '\n';
}

size_t max_element(double* vec, const size_t n) {
    size_t max = 0;
    for (size_t i = 1; i < n; ++i) {
        if (vec[max] < vec[i]) max = i;
    }
    return max;
}

void sum(double* vec, const size_t n) {
    const auto pos = max_element(vec, n);
    auto sum = 0.0;
    for (size_t i = 0; i < pos; ++i) sum += vec[i];
    cout << "Sum: " << sum << '\n';
}

int main() {
    size_t n = 0;
    double* vec = nullptr;
    auto flag = false;
    while (true) {
        puts("Input char C => Create Array");
        if (vec) {
            puts("Input char F => Fill");
            puts("Input char R => Random Fill");
            if (flag) {
                puts("Input char A => Average");
                puts("Input char S => Sum");
            }
        }
        puts("Input char E => Exit");
        switch (point()) {
        case Menu::Create:
            destroy(vec);
            n = size_t_parse("Input size: ");
            vec = create(n);
            if (!vec) puts("Not enough memory!");
            break;
        case Menu::Fill: flag = fill(vec, n); break;
        case Menu::Random: flag = rand(vec, n); break;
        case Menu::Average: average(vec, n); break;
        case Menu::Sum: sum(vec, n); break;
        case Menu::Exit: return 0;
        case Menu::Exit: if (destroy(vec) == nullptr) return 0;
        default: puts("Invalid input!");
        }
    }
}