Удалить из массива строк самую короткую строку

#include <iostream>
#include <time.h>
#include <math.h>
#include <string>
 
using namespace std;
 
int main()
{
    srand(time(0));
    const int n = 10;
    string *s = new string[n];
    int min = 0;
    for (int i = 0; i < n; i++)
    {
        cout << i << ": ";
        s[i].resize(rand() % 30+1);
        if (s[i].size() < s[min].size())
            min = i;
        for (int j = 0; j < s[i].size() - 1; j++)
        {
            switch (rand() % 3)
            {
            case 0:s[i][j] = rand() % 27 + 'a'; break;
            case 1:s[i][j] = rand() % 27 + 'A'; break;
            case 2:s[i][j] = rand() % 10 + '0'; break;
            }
        }
        s[i][s[i].size() - 1] = '\0';
        cout << s[i] << endl;
    }
    s[min] = "";
    cout << endl;
    for (int i = 0; i < n; i++)
    {
        cout << i << ": ";
        cout << s[i] << endl;
    }
    cin.get();
}

#include <iostream>
#include <string>
#include <malloc.h>
using namespace std;
 
int main()
{
    setlocale(LC_ALL, "rus");
    string Text;
    int SizeOfMassive = 0;
    cout << "Введите нужное количество строк: ";
    cin >> SizeOfMassive;
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    string **ppMassive = new string*[SizeOfMassive];
    for (int i = 0; i < SizeOfMassive; i++)
    {
        cin >> Text;
        ppMassive[i] = new string[Text.length() + 1];
        *ppMassive[i] = Text;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    int *pSizeOfMassive = new int[SizeOfMassive + 1];
    int SizeOfLittleWord = 0;
    int NumberOfMassive = 0;
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    for (int i = 0; i < SizeOfMassive; i++)
    {
        pSizeOfMassive[i] = _msize(ppMassive[i]) / sizeof(ppMassive[i]);
        SizeOfLittleWord += pSizeOfMassive[i];
    }
    for (int i = 0; i < SizeOfMassive; i++)
    {
        if (SizeOfLittleWord > pSizeOfMassive[i])
        {
            SizeOfLittleWord = pSizeOfMassive[i];
            NumberOfMassive = i;
        }
    }
    for (int i = NumberOfMassive; i > SizeOfMassive; i++)
    {
        *ppMassive[i] = *ppMassive[i + 1];
        delete ppMassive[SizeOfMassive];
    }
    //Вывод на экран
    for (int i = 0; i < SizeOfMassive; i++)
    {
        cout << *ppMassive[i] << endl;
    }
    system("pause");
    return 0;
}

#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
#include <vector>
 
int main()
{
    using v_str = std::vector<std::string>;
    auto print_v = [](const v_str &v)
    {
        std::copy(v.cbegin(), v.cend(), std::ostream_iterator<std::string>(std::cout, "\n"));
        std::cout << "***************\n";
    };
    auto lessLength = [](const std::string &lhs, const std::string &rhs)
    {
        return lhs.length() < rhs.length();
    };
 
    std::uniform_int_distribution<char> charDist('a', 'z');
    std::uniform_int_distribution<int> lengthDist(1, 15);
    std::default_random_engine gen{ std::random_device()() };
 
    const size_t numWords = 7;
    v_str words(numWords);
    std::generate(words.begin(), words.end(), [&charDist, &lengthDist, &gen]
    {
        std::string result;
        for (int i = lengthDist(gen); i != 0; i--)
            result += charDist(gen);
        return result;
    });
 
    print_v(words);
    words.erase(std::min_element(words.begin(), words.end(), lessLength));
    print_v(words);
}

std::generate(words.begin(), words.end(), [&charDist, &lengthDist, &gen]
{
    std::string result(lengthDist(gen), ' ');
    std::generate(result.begin(), result.end(), [&charDist, &gen] { return charDist(gen); });
    return result;
});

#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
#include <vector>
 
int main()
{
    using v_str = std::vector<std::string>;
    auto print_v = [](const v_str &v)
    {
        std::copy(v.cbegin(), v.cend(), std::ostream_iterator<std::string>(std::cout, "\n"));
        std::cout << "***************\n";
    };
    auto lessLength = [](const std::string &lhs, const std::string &rhs)
    {
        return lhs.length() < rhs.length();
    };
 
    std::uniform_int_distribution<char> charDist('a', 'z');
    std::uniform_int_distribution<int> lengthDist(1, 15);
    std::default_random_engine gen{ std::random_device()() };
 
    const size_t numWords = 7;
    v_str words(numWords);
    std::generate(words.begin(), words.end(), [&charDist, &lengthDist, &gen]
    {
        std::string result;
        std::generate_n(std::back_inserter(result), lengthDist(gen), [&charDist, &gen] { return charDist(gen); });
        return result;
    });
 
    print_v(words);
    words.erase(std::min_element(words.begin(), words.end(), lessLength));
    print_v(words);
}

std::bind(charDist, gen)

std::function<char()> charGen = std::bind(charDist, gen);

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <random>
#include <vector>
 
int main()
{
    using v_str = std::vector<std::string>;
    auto print_v = [](const v_str &v)
    {
        std::copy(v.cbegin(), v.cend(), std::ostream_iterator<std::string>(std::cout, "\n"));
        std::cout << "***************\n";
    };
    auto lessLength = [](const std::string &lhs, const std::string &rhs)
    {
        return lhs.length() < rhs.length();
    };
 
    std::uniform_int_distribution<char> charDist('a', 'z');
    std::uniform_int_distribution<int> lengthDist(1, 15);
    std::default_random_engine gen{ std::random_device()() };
    std::function<char()> charGen = std::bind(charDist, gen);
    std::function<int()> lengthGen = std::bind(lengthDist, gen);
 
    const size_t numWords = 7;
    v_str words(numWords);
    std::generate(words.begin(), words.end(), [&charGen, &lengthGen]
    {
        std::string result;
        std::generate_n(std::back_inserter(result), lengthGen(), [&charGen] { return charGen(); });
        return result;
    });
 
    print_v(words);
    words.erase(std::min_element(words.begin(), words.end(), lessLength));
    print_v(words);
}

[&charGen] { return charGen(); }