Задачи для тренировки и лучшего понимания

int matrix[n][m];
// ...
matrix[n][m] = { 0 };

class Test {
  private:
    int mas[3][3];
  public:
    Test();
    void PrintValues();
    void Clear();
};
Test::Test()
{
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
      mas[i][j] = i+j;
    }
  }
}
void Test::PrintValues()
{
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
      cout << mas[i][j] << " ";
      if (j ==  2) cout << endl;
    }
  }
}
void Test::Clear()
{
  memset(mas,NULL,sizeof(mas));
}

ZeroMemory(mas,sizeof(mas));

//////////////////////////////////////////////////////////////////////////////////////
//Напишите программу, которая посчитает количество смайликов в заданном тексте. 
//Смайликом будем считать последовательность символов, удовлетворяющую условиям:
//
//    * Первым символом является либо ; (точка с запятой), либо : (двоеточие) ровно 
//один раз
//    * Далее может идти символ - (минус) сколько угодно раз (в том числе минус может 
//идти ноль раз)
//    * В конце обязательно идёт некоторое количество (не меньше одной) одинаковых 
//скобок из следующего набора: (, ), [, ].
//    * Внутри смайлика не может встречаться никаких других символов.
//////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <ctime>
#include <string>
#include <algorithm>
#include <iomanip>
 
typedef std::string  T_str;
 
enum T_smile_symb
{
    DVOETOCHIE        = ':',
    COMA_DOT          = ';',
    TIRE              = '-',
    SKOBKA_KRUGL_OTKR = '(',
    SKOBKA_KRUGL_ZAKR = ')',
    SKOBKA_KVADR_OTKR = '[',
    SKOBKA_KVADR_ZAKR = ']'
};
 
class T_count_smiles
{
    enum T_smile_state
    {
        NOT_SMILE_ST         = '!',        
        TIRE_ST              = TIRE,
        SKOBKA_KRUGL_OTKR_ST = SKOBKA_KRUGL_OTKR,
        SKOBKA_KRUGL_ZAKR_ST = SKOBKA_KRUGL_ZAKR,
        SKOBKA_KVADR_OTKR_ST = SKOBKA_KVADR_OTKR,
        SKOBKA_KVADR_ZAKR_ST = SKOBKA_KVADR_ZAKR
    };
    //------------------------------------------------------------------------------
    char   cur_smile_state_;
    int    smile_count_;
    T_str  cur_smile_;
    //------------------------------------------------------------------------------
public:
    //------------------------------------------------------------------------------
    T_count_smiles() : cur_smile_state_(NOT_SMILE_ST), smile_count_(0)
    {}
    //------------------------------------------------------------------------------
    void operator() (char symb)
    {
        switch(cur_smile_state_)
        {
        case NOT_SMILE_ST: 
            not_smile(symb);
            break;
        case TIRE_ST: 
            tire(symb);
            break;
        case SKOBKA_KRUGL_OTKR_ST: 
        case SKOBKA_KRUGL_ZAKR_ST: 
        case SKOBKA_KVADR_OTKR_ST: 
        case SKOBKA_KVADR_ZAKR_ST:             
            skobka(symb);
            break;
        }    
    }
    //------------------------------------------------------------------------------
    operator int ()
    {
        return  smile_count_;
    }
    //------------------------------------------------------------------------------
private:
    //------------------------------------------------------------------------------
    void  not_smile(char symb)
    {
        if(is_smile_glaza(symb))
        {
            cur_smile_.assign(1, symb);
            cur_smile_state_ = TIRE_ST;            
        }        
    }
    //------------------------------------------------------------------------------
    void  tire(char symb)
    {
        if(is_tire(symb))
        {
            cur_smile_ += symb;
        }
        else
        {
            if(is_skobka(symb))
            {
                cur_smile_       += symb;
                cur_smile_state_ =  symb;                            
            }            
            else
            {
                cur_smile_state_ = NOT_SMILE_ST;
                operator()(symb);
            }            
        }           
    }   
    //------------------------------------------------------------------------------
    void  skobka(char symb)
    {
        if(symb == cur_smile_state_)
        {
            cur_smile_ += symb;
        }
        else
        {
            ++smile_count_;            
            std::cout << std::setw(3)
                      << smile_count_
                      << ")  "
                      << cur_smile_
                      << std::endl;
            cur_smile_state_ = NOT_SMILE_ST; 
            operator()(symb);
        }
    }
    //------------------------------------------------------------------------------
    bool is_smile_glaza(char symb)
    {
        return    symb == DVOETOCHIE
               || symb == COMA_DOT;
    }
    //------------------------------------------------------------------------------
    bool is_tire(char symb)
    {
        return symb == TIRE_ST;
    }
    //------------------------------------------------------------------------------
    bool is_skobka(char symb)
    {
        return    symb == SKOBKA_KRUGL_OTKR_ST
               || symb == SKOBKA_KRUGL_ZAKR_ST
               || symb == SKOBKA_KVADR_OTKR_ST
               || symb == SKOBKA_KVADR_ZAKR_ST;        
    }
    //------------------------------------------------------------------------------
};
 
T_str  get_rand_smile_str(int size)
{   
    struct T_gen_smile_symb
    {
        T_str  smile_symbols_;
        T_gen_smile_symb()
        {
            smile_symbols_.push_back(DVOETOCHIE);
            smile_symbols_.push_back(COMA_DOT);
            smile_symbols_.push_back(TIRE);
            smile_symbols_.push_back(TIRE);
            smile_symbols_.push_back(TIRE);
            smile_symbols_.push_back(TIRE);
            smile_symbols_.push_back(SKOBKA_KRUGL_OTKR);
            smile_symbols_.push_back(SKOBKA_KRUGL_ZAKR);
            smile_symbols_.push_back(SKOBKA_KVADR_OTKR);
            smile_symbols_.push_back(SKOBKA_KVADR_ZAKR);        
        }
        char operator() ()
        {
            return smile_symbols_[rand() % smile_symbols_.length()];
        }
    };
 
    T_str rand_smile_str(size, 0);
    std::generate(rand_smile_str.begin(), rand_smile_str.end(), T_gen_smile_symb());
    return rand_smile_str += ' ';
}
 
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
    const int SMILE_STR_LEN = 80;
    T_str  rand_smile_str = get_rand_smile_str(SMILE_STR_LEN);      
    std::cout << rand_smile_str
              << std::endl;
    int smile_count = std::for_each(rand_smile_str.begin(), rand_smile_str.end(), 
                                    T_count_smiles());
 
    std::cout << "Итого "
              << smile_count
              << " смайлов."
              << std::endl;
    return 0;
}

#ifndef _CELL_H_
#define _CELL_H_
class Cell
{
    private:
        bool state;                                 //состояние клетки: true/false = жива/мертва
    public:                
        Cell();
        bool isalive(void);                       //проверяет, жива ли клетка
        bool isdead(void);                       //проверяет, мертва ли клетка. в принципе, можно было бы  обойтись только функцией isalive(), но всё таки 
        void setalive(void);                     //"оживляет" клетку
        void setdead(void);                     //"убивает" клетку
        void setto(int i);                         //убивает/оживлаят клетку. работает на rand().
};
#endif

#include "cell.h"
#include <iostream>
#include <string.h>
 
bool Cell::isalive(void)
{
    if (state==true)
        return true;
    else if (state==false)
             return false;
};
bool Cell::isdead(void)
{
    if (state==false)
        return true;
    else if (state==true)
             return false;
};
void Cell::setalive(void)
{
    state=true;
};
void Cell::setdead(void)
{
    state=false;
};
Cell::Cell()
{
};
void Cell::setto(int i)
{
    if (i==1)
        setalive();
    else if (i==0)
             setdead();
         else std::cout<<"\nError\n";
};

#include <iostream>
#include <time.h>
#include "cell.h"
#include "cell.cpp"
int main()
{
    srand(time(NULL));
    std::cout<<"Enter the size of array: ";
    int nn;
    std::cin>>nn;
    const int n=nn;
    std::cout<<"Enter the amount of live cells: ";
    int kk;
    std::cin>>kk;
    const int k=kk;
    Cell field[n][n];
    int m,l;
    for(int m;m<n;m++)
    {
        for(int l;l<n;l++)
        {
            field[m][l].setto(rand()%2);
        };
    };
    for(int m;m<n;m++)
    {
        for(int l;l<n;l++)
        {
            if (field[m][l].isalive())
                std::cout<<"0";
            if (field[m][l].isdead())
                std::cout<<" ";
        };
        std::cout<<"\n";
    };
    std::cin>>l;
    return 0;
}

#ifndef _CELL_H_
#define _CELL_H_
 
#include <iostream>
 
namespace cell
{
    enum state
    {
        alive = true,
        dead = false
    };
 
    class cell
    {
    private:
        state st;
    public:                
        cell();
        ~cell();
        state getState() const;
        void setState(state s);
        friend std::ostream& operator << (std::ostream& os, const cell& rc);
    };
};
#endif

#include "cell.h"
 
namespace cell
{
    cell::cell()
        : st(dead)
    {
    }
    cell::~cell()
    {
    }
    state cell::getState() const
    {
        return st;
    }
    void cell::setState(state s)
    {
        st = s;
    }
    std::ostream& operator << (std::ostream& os, const cell& rc)
    {
        os << ( rc.st ? '0' : ' ' );
        return os;
    }
};

#include <iostream>
#include <ctime>
#include "cell.h"
 
int main()
{
    srand(static_cast<unsigned int>(time(NULL)));
    size_t n, m;
    std::cout << "Input n: ";
    std::cin >> n;
    std::cout << "Input m: ";
    std::cin >> m;
    cell::cell** cl = new cell::cell*[n];
    for(size_t i=0; i<n; ++i, std::cout << std::endl)
    {
        cl[i] = new cell::cell[m];
        for(size_t j=0; j<m; ++j)
        {
            cell::state st = rand()%2 ? cell::alive : cell::dead;
            cl[i][j].setState(st);
            std::cout << cl[i][j];
        }
    }
    for(size_t i=0; i<n; ++i)
        delete[] cl[i];
    delete[] cl;
    system("pause");
    return EXIT_SUCCESS;
}