Работа с файлами (считывание и запись)

#include <iostream>
#include <cstdlib>
#include <time.h>
#include <fstream>
using namespace std;
int main()
{
    setlocale(LC_ALL, "ru");
    srand(time(NULL));
    int res = 0, i, min, max, num;
    ofstream File("doc.txt");
    if (!File) {
        cout << "Ошибка: файл не найден" << endl;
        return 1;
    }
    for (i = 0; i < 10; i++) {
        num = rand() % 30;
        File << num;
    }
    File.close();
    ifstream File2("doc.txt");
    int get, k;
    int A[1000];
    if (!File2) {
        cout << "Файл не найден!" << endl;
    }
    else {
        k = 0;
        while (File2 >> get) {
            A[k++] = get;
        }
        max = A[0];
        min = A[0];
        for (i = 0; i < 10; i++) {
            if (max < A[i])
                max = A[i];
            if (min > A[i])
                min = A[i];
        }
        cout << "Максимальное значение массива: " << max << endl;
        cout << "Минимальное значение массива: " << min << endl;
        res = max + min;
    }
    File2.close();
    cout << "Результат: " << res << endl;
    system("pause");
    return 0;
}

А вы не хотите разделять выводимые числа, например, пробелами? Или с новой строки? А не лепить их в одно большое число?

Скажем,

for (i = 0; i < 10; i++) {
    num = rand() % 30;
    File << num << " ";
}

Если бы вы не полагались на "магическую константу" 10, а сделали вот так:

    k = 0;
    while (File2 >> get) {
        A[k++] = get;
    }
    cout << "Считано " << k << " чисел" << endl;
    max = A[0];
    min = A[0];
    for (i = 0; i < k; i++) {

то ошибка стала бы очевидной сразу...

Вот зачем вам понадобилось хранить прочитанное в массиве, непонятно. Все что нужно сделать, это вот:

//учитывая, что ваши числа от 0 до 30
int max = -1, min = 31,
    n{}, cur{};
while (File2 >> cur && n < 10) {
    if (max < cur) max = cur;
    if (min > cur) min = cur;
    ++n;
}
cout << "minel " << min
     << "\nmaxel " << max
     << "\nsum = " << min + max;

Да, еще и при записи в файл вы ошиблись(см. ответ от Harry}

#include <iostream>
#include <vector>
#include <functional>
#include <random>
#include <cstdint>
#include <filesystem>
#include <iterator>
#include <fstream>

static decltype(auto) GetRandomEngine(int64_t bottomBorder, int64_t upperBorder) noexcept
{
    std::mt19937_64 generator(std::random_device{}());
    std::uniform_int_distribution<> uid(bottomBorder, upperBorder);
    return std::bind(uid, generator);
}

static std::vector<int64_t> GetVectorWithEntropy(uint64_t size, int64_t bottomBorder, int64_t upperBorder) noexcept
{
    auto random_generator{GetRandomEngine(bottomBorder, upperBorder)};
    std::vector<int64_t> data(size);
    std::generate(std::begin(data), std::end(data), random_generator);
    return data;
}

static std::filesystem::path CheckAndGetFileDescriptor(std::string file_name, bool exists)
{
    auto file_path = std::filesystem::current_path() / file_name;
    if (exists && std::filesystem::exists(file_path)) {
        throw std::runtime_error{"Error! file exist"};
    }
    if (!exists && !std::filesystem::exists(file_path)) {
        throw std::runtime_error{"Error! file no exist"};
    }
    return file_path;
}

template<typename T>
static void WriteDataToFile(std::vector<T> data, std::string file_name) 
{
    std::ofstream out_stream(CheckAndGetFileDescriptor(file_name, true), std::ios::out);
    if (!out_stream.is_open()) {
        throw std::runtime_error{"Error open file"};
    }
    std::copy(std::begin(data), std::end(data), std::ostream_iterator<int64_t>{out_stream, " "});
    out_stream.close();
}

template<typename T, auto MaxOrMin>
static T GetMaxOrMinValueFromFile(std::string file_name)
{
    T ret{};
    if (MaxOrMin) {
        ret = std::numeric_limits<T>::min();
    } else {
        ret = std::numeric_limits<T>::max();
    }
    auto f_obj{ [&](T n){ MaxOrMin ? ret = std::max(ret, n) : ret = std::min(ret, n);} };
    std::ifstream in_stream(CheckAndGetFileDescriptor(file_name, false), std::ios::in);
    if (!in_stream.is_open()) {
        throw std::runtime_error{"Error open file"};
    }
    std::for_each(std::istream_iterator<T>(in_stream), std::istream_iterator<T>(), f_obj);   
    in_stream.close();
    return ret;
}

int main()
{
    int64_t bottom{0};
    int64_t upper{30};
    uint64_t size{10};
    std::string file_name{"information"};
    auto data{GetVectorWithEntropy(size, bottom, upper)};
    try {
        WriteDataToFile<int64_t>(data, file_name);
        int64_t max_value{GetMaxOrMinValueFromFile<int64_t, true>(file_name)};
        int64_t min_value{GetMaxOrMinValueFromFile<int64_t, false>(file_name)};
        std::cout << "Maximum value : " << max_value << std::endl;
        std::cout << "Minimum value : " << min_value << std::endl;
        std::cout << "Sum : " << max_value + min_value << std::endl;
    } catch(std::exception& e) {
        std::cerr << e.what() << std::endl;
        return -1;
    }
    return 0;
}