Разработать метод производного класса определяющий частоты повторения символов

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
 
class char_sequence
{
public:
    // construction & destruction
    char_sequence() = default;
    char_sequence(const char* characters) : m_data(characters) { }
    char_sequence(const std::string& characters) : m_data(characters) { }
    char_sequence(std::string&& characters) : m_data(std::move(characters)) { }
    char_sequence(const char_sequence& other) = default;
    char_sequence(char_sequence&& other) = default;
    virtual ~char_sequence() { }
    // assignment
    char_sequence& operator=(const char* characters) {
        m_data = characters;
        return *this;
    }
    char_sequence& operator=(const std::string& characters) {
        m_data = characters;
        return *this;
    }
    char_sequence& operator=(std::string&& characters) {
        m_data = std::move(characters);
        return *this;
    }
    char_sequence& operator=(const char_sequence& other) = default;
    char_sequence& operator=(char_sequence&& other) = default;
    // output
    friend std::ostream& operator<<(std::ostream& os, const char_sequence& seq)
    {
        os << seq.m_data.c_str();
        return os;
    }
 
protected:
    std::string m_data;
}; // char_sequence
 
class enhanced_char_sequence : public char_sequence
{
public:
    // construction
    enhanced_char_sequence() = default;
    enhanced_char_sequence(const char* characters) : char_sequence(characters) { }
    enhanced_char_sequence(const std::string& characters) : char_sequence(characters) { }
    enhanced_char_sequence(std::string&& characters) : char_sequence(std::move(characters)) { }
    enhanced_char_sequence(const char_sequence& other) : char_sequence(other) { }
    enhanced_char_sequence(char_sequence&& other) : char_sequence(std::move(other)) { }
    // assignment
    enhanced_char_sequence& operator=(const char* characters) {
        *dynamic_cast<char_sequence*>(this) = characters;
        return *this;
    }
    enhanced_char_sequence& operator=(const std::string& characters) {
        *dynamic_cast<char_sequence*>(this) = characters;
        return *this;
    }
    enhanced_char_sequence& operator=(std::string&& characters) {
        *dynamic_cast<char_sequence*>(this) = std::move(characters);
        return *this;
    }
    enhanced_char_sequence& operator=(const char_sequence& other) {
        *dynamic_cast<char_sequence*>(this) = other;
        return *this;
    }
    enhanced_char_sequence& operator=(char_sequence&& other) {
        *dynamic_cast<char_sequence*>(this) = std::move(other);
        return *this;
    }
    // output
    friend std::ostream& operator<<(std::ostream& os, const enhanced_char_sequence& seq) {
        os << dynamic_cast<const char_sequence&>(seq);
        return os;
    }
    // get character frequency
    float get_frequency(char c);
    auto get_frequencies();
 
protected:
    // calculate character repetition
    void calc_repetition();
 
    std::map<char, int> m_repetition;
};
 
void enhanced_char_sequence::calc_repetition() {
    m_repetition.clear();
    std::for_each(std::begin(m_data), std::end(m_data), [this](auto c) { ++m_repetition[c]; });
}
 
float enhanced_char_sequence::get_frequency(char c) {
    calc_repetition();
    auto rep_pos = m_repetition.find(c);
    if (rep_pos == m_repetition.end()) return 0.0;
    return (rep_pos->second + 0.0) / m_data.size();
}
 
auto enhanced_char_sequence::get_frequencies() {
    calc_repetition();
    std::map<char, float> frequencies;
    std::for_each(std::begin(m_repetition), std::end(m_repetition),
        [this, &frequencies](auto& c) { frequencies[c.first] = (c.second + 0.0) / m_data.size(); }
    );
    return frequencies;
}
 
int main()
{
    // create all
    char_sequence cs1 = "fjjgihij";
    char_sequence cs2 = "iijmkjllimi";
    enhanced_char_sequence ecs1 = "abcdeabaffga";
    enhanced_char_sequence ecs2(cs1);
    enhanced_char_sequence ecs3(std::move(cs2));
    enhanced_char_sequence ecs4(ecs2);
    // output all
    std::cout << "cs1:  " << cs1  << std::endl;
    std::cout << "cs2:  " << cs2  << std::endl;
    std::cout << "ecs1: " << ecs1 << std::endl;
    std::cout << "ecs2: " << ecs2 << std::endl;
    std::cout << "ecs3: " << ecs3 << std::endl;
    std::cout << "ecs4: " << ecs4 << std::endl;
    // get frequency for a given char
    std::cout << "frequency of \'a\' in ecs1: " << ecs1.get_frequency('a') << std::endl;
    std::cout << "frequency of \'a\' in ecs2: " << ecs2.get_frequency('a') << std::endl;
    std::cout << "frequency of \'i\' in ecs3: " << ecs3.get_frequency('i') << std::endl;
    // get frequencies for all characters
    std::cout << "Frequencies for ecs1:" << std::endl;
    for (const auto [c, freq] : ecs1.get_frequencies()) {
        std::cout << c << " : " << freq << std::endl;
    }
 
    return 0;
}

///----------------------------------------------------------------------------|
/// Самая частая буква.
/// С++11
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <algorithm>
 
///----------------------------------------------------------------------------|
/// В помощь.
///----------------------------------------------------------------------------:
struct mystring : public std::string
{   mystring(std::string S) : std::string(S)
    {
    }
 
private:
    struct Let
    {   Let() : cnt(0)
        {   c = cc++;
        }
        int cnt;
        char  c;
        static char cc;
    };
    
public:
    void statistic()
    {   const int N = 256;
        Let   m  [N];
        
        const auto& s = std::string(data());
 
        for(auto i = s.begin(); i != s.end(); ++i)
        {   char c = *i;
            if(std::isalpha(c)) m[toupper(c)].cnt++;
        }
 
        std::sort(m, m + N,
                  [](const Let& a, const Let& b) -> bool
        {   return a.cnt > b.cnt;
        });
 
        std::cout << s;
 
        if(m[0].cnt == 0)
        {   std::cout << "WARNING: The string does not contain valid characters!\n";
        }
        else for(size_t i = 0; m[i].cnt != 0; ++i)
            {   std::cout << "    "<< m[i].c << " - " << m[i].cnt << "\n";
            }
    }
};
char mystring::Let::cc = 0;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    mystring s("Суть задания: Разработать метод-член производного \n"
               "класса определения частоты повторения символов. \n"
               "Я без понятия как это делать\n\n");
 
    s.statistic();
    std::cout << "Всего символов: " << s.size();
}