Образцы (шаблоны) программ для типовых задач

#include <iostream>
//#include <clocale>
using namespace std;
//----- объявление прототипов используемых функций-----------------
int** Create(int n,int m);           // создание матрицы n строк m столбцов
void Free(int** M,int n);             // освобождение матрицы
void Input(int** M,int n,int m);   // ввод матрицы
void Print(int** M,int n,int m);     // вывод матрицы
//--------------------------------------------------------------------------
void Work(int** M,int n,int m);    // обработка матрицы
//   Сюда добавить протопипы тех функций которые дополнительно напишете
//--------------------------------------------------------------------------
 
//----------  main() -  точка входа в программу консольного приложения 
int main()
{
    //setlocale(LC_ALL,"Rus");
    int n,m;
    cout<<"Количество строк матрицы:?";
    cin>>n;
    cout<<"Количество столбцов матрицы:?";
    cin>>m;
    int** A=Create(n,m);
    Input(A,n,m);
    Work(A,n,m);
    Free(A,n);
    //system("pause");
    return 0;
}
 
//----   описание функций -----------------------------------------
int** Create(int n,int m)
{
    int** M=new int*[n];
    for(int i=0;i<n;i++)
    {
        M[i]=new int[m];
    }
    return M;
}
//----------------------------
void Free(int** M,int n)
{
    for(int i=0;i<n;i++)
        delete[] M[i];
    delete[] M;
}
//----------------------------
void Input(int** M,int n,int m)
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cout<<"M["<<i<<"]["<<j<<"]=?";
            cin >> M[i][j];
        }
    
    }
}
//----------------------------
void Print(int** M,int n,int m)
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cout << M[i][j] << " ";
        }
        cout << endl;
    }
}
// пример обработки - подсчет сумм в каждой строке
void Work(int** M,int n,int m)
{
    for(int i=0;i<n;i++)
    {
        int sum=0;
        for(int j=0;j<m;j++)
        {
             sum+=M[i][j];
        }
        cout<<i<<" sum = " << sum<< endl;
    }
}
// сюда вставить все дополнительные функции которые напишете

#include <iostream>
//#include <clocale>
#include <cstdlib>
using namespace std;
//----- объявление прототипов используемых функций----------------------------------------
void Input(int* M,int n);  // ввод массива
void Print(int* M,int n);   // вывод массива
void RandomFill(int* M,int n);   // заполнение массива случайными числами
//--------------------------------------------------------------------------
int Work(int* M,int n);   // пример обработки массива
//   Сюда добавить протопипы тех функций которые дополнительно напишете
//--------------------------------------------------------------------------
 
//----------  main() -  точка входа в программу консольного приложения 
int main()
{
    //setlocale(LC_ALL,"Rus");
    int n;
    cout<<"Размер массива?";
    cin>>n;
    int* A=new int[n];
    //Input(A,n);
    RandomFill(A,n);
    Print(A,n); 
    int s=Work(A,n);
    cout<<"Summa = " << s<< endl;
    delete[] A;
    //system("pause");
    return 0;
}
//----   описание функций -----------------------------------------
// ввод массива
void Input(int* M,int n)
{
    for(int i=0;i<n;i++)
    {
        cout<<"M["<<i<<"]=?";
            cin >> M[i];
    }
}
// заполнение случайными числами
void RandomFill(int* M,int n)
{
    for(int i=0;i<n;i++)
    {
        M[i]=rand()%100;
    }
}
  // вывод массива
void Print(int* M,int n)
{
    for(int i=0;i<n;i++)
    {
        cout << M[i]<< " ";
    }
    cout << endl;
}
// пример обработки - подсчет суммы элементов
int Work(int* M,int n)
{
    int sum=0;
    for(int i=0;i<n;i++)
    {
        sum+=M[i];
    }
    return sum;
}
// сюда вставить все дополнительные функции которые напишете

#include <iostream>
#include <cstring>
using namespace std;
 
class AA
{
private:
    // здесь данные и методы, которые используются только в базовом классе
protected:
    // здесь данные и методы, которые доступны в производном классе
char* str; // для примера строка с динамически выделяемой памятью
public:
    virtual ~AA(){delete[] str;} // деструктор
    AA(){str=new char[1];*str=0;} // конструктор по умолчанию
    AA(char* x)     // конструктор с параметрами
    {
        str=new char[strlen(x)+1];
        strcpy(str,x);
    }
    AA(const AA& a)  // копиконструктор
    {
        str=new char[strlen(a.str)+1];
        strcpy(str,a.str);
    }
    AA& operator=(const AA& a)  // operator= (правило ТРЕХ)
    {
        if(this==&a)  // обязательно проверяем, что нет присвоения типа x=x;
            return *this;
        if(strlen(str)!=strlen(a.str))
        {
            delete[] str;
            str=new char[strlen(a.str)+1];
        }
        strcpy(str,a.str);
        return *this;
    }
    virtual void f(){cout<<" class A\n";} // виртуальная функция
    friend ostream& operator<<(ostream& os,const AA& a); // перегрузка потокового вывода
    friend istream& operator>>(istream& os,AA& a); // перегрузка потокового ввода
};
//-----------------------------------------------------
ostream& operator<<(ostream& os,const AA& a)
{
    os<<a.str<<endl;
    return os;
}
istream& operator>>(istream& is,AA& a)
{
    char tmp[100];
    is.getline(tmp,100);
    delete[] a.str;
    a.str=new char[strlen(tmp)+1];
    strcpy(a.str,tmp);
    return is;
}
//-----------------------------------------------------
 
class BB : public AA
{
private:
    int SIZE; // дополнительные данные
public:
    ~BB(){}
    BB():AA(){SIZE=strlen(str);}
    BB(char* x):AA(x){SIZE=strlen(str);} // обязательно вызываем конструктор базового класса
    BB(BB& a):AA(a){SIZE=strlen(str);} // обязательно вызываем конструктор базового класса
    BB& operator=(const BB& a)  
    {
        if(this==&a)
            return *this;
        if(SIZE!=a.SIZE)
        {
            delete[] str;
            str=new char[SIZE+1];
        }
        strcpy(str,a.str);
        return *this;
    }
    void f(){cout<<" class B\n";}
    friend ostream& operator<<(ostream& os,const BB& a);
    friend istream& operator>>(istream& os,BB& a);
 
};
//-----------------------------------------------------
ostream& operator<<(ostream& os,const BB& a)
{
    os<<a.str<<" Size="<<a.SIZE<<endl;
    return os;
}
istream& operator>>(istream& is,BB& a)
{
 
    char tmp[100];
    is.getline(tmp,100);
    delete[] a.str;
    a.SIZE=strlen(a.str);
    a.str=new char[a.SIZE+1];
    strcpy(a.str,tmp);
    return is;
}
//----------------------------------------------------- 
int main() 
{
    char tst[]="Hello";
    AA a(tst);  // базовый класс
    a.f();      // невиртуальный вызов f() из AA
    AA a2;
    a2=a;  // operator=
    cout<<a2;
    
    BB b(tst);  // производный класс
    b.f();      // невиртуальный вызов f() из BB
    BB b2=b;    // копиконструктор эквивалентно BB b2(b);
    cout<<b;  
 
    AA* pa; 
// Указателю на базовый класс присваиваем адрес ПРОИЗВОДНОГО класса:
    pa=&b;   
    pa->f();// виртуальный вызов f() из B
    pa->AA::f();// невиртуальный вызов f() из AA
 
    //system("pause");
    return 0;
}

#include <iostream>
#include <clocale>
#include <cstdlib>
#include <ctime>
//
// Создание матрицы
//
int ** Create( size_t n, size_t m ) {
    int ** M = new int * [n];
    for ( size_t i = 0; i < n; ++i ) {
        M[i] = new int [m];
    }
    return M;
}
//
// Удаление матрицы
//
void Free( int ** M, size_t n ) {
    for ( size_t i = 0; i < n; ++i ) {
        delete [] M[i];
    }
    delete [] M;
}
//
//---- ввод матрицы--------------------------------------
//
void Input( int ** M, size_t n, size_t m ) {
    for ( size_t i = 0; i < n; ++i ) {
        for ( size_t j = 0; j < m; ++j ) {
            std::cout << "M[" << i << "][" << j << "] = ";
            std::cin >> M[i][j];
        }
    }
}
//
// заполнение матрицы случайными числами из диапазона [0, 99] -----------
//
void FillRandomNumbers(int **matrix, const size_t rows, const size_t columns)
{
    srand((unsigned int)time(0)); // инициализируем ПГСЧ
 
    for (size_t row=0; row < rows; row++)
        for (size_t column=0; column < columns; column++)
            matrix[row][column] = rand() % 100; // присваиваем СЧ
}
//
//-------- Печать матрицы ------------------------------------------------
//
void Print( int ** M, size_t n, size_t m ) {
    for ( size_t i = 0; i < n; ++i ) {
        for ( size_t j = 0; j < m; ++j ) {
            std::cout<<M[i][j]<<' ';
        }
        std::cout<<std::endl;
    }
}
//
// пример обработки матрицы - подсчет сумм в каждой строке
//
void Process( int ** M,int *Sum, size_t n, size_t m ) {
    for ( size_t i = 0; i < n; ++i ) {
        Sum[i] = 0;
        for ( size_t j = 0; j < m; ++j ) {
            Sum[i] += M[i][j];
        }
    }
}
 
// ...
// сюда вставить все дополнительные функции которые напишете
// ...
 
int main()
{
    //setlocale( LC_ALL, "Rus" ); // установление русской локали (windows)
 
    size_t n, m;
 
    // вводим размерность матрицы
    std::cout << "Введите количество строк матрицы: ";
    std::cin >> n;
    std::cout << "Введите количество столбцов матрицы: ";
    std::cin >> m;
 
    // выделяем память под матрицу
    int ** A = Create( n, m );
 
    // ввод матрицы
    //Input( A, n, m );
    // заполнение случайными числами (вместо ввода)
    FillRandomNumbers(A,n,m);
 
    // обработка матрицы
    int* S=new int[n]; // Вектор результата
    Process( A, S, n, m );
 
    // вывод результата
    for(size_t i=0;i<n;i++) 
        std::cout<< S[i] <<' ';
    std::cout<<std::endl;
 
    // Вывод матрицы
    Print(A,n,m);
 
    // освобождаем память, выделенную под матрицу и вектор
    delete[] S;
    Free( A, n );
 
    // ждём нажатия клавиши перед выходом из приложения (windows)
    //system( "pause" );
 
    return 0;
}

//#include <clocale>
#include <cstdlib>
#include <ctime>
#include <iostream>
 
/// заполнение матрицы случайными числами из диапазона [0, 99]
void FillRandomNumbers(int **matrix, const size_t rows, const size_t columns)
{
    srand(time(0)); // инициализируем ПГСЧ
 
    for (size_t row=0; row < rows; row++)
        for (size_t column=0; column < columns; column++)
            matrix[row][column] = rand() % 100; // присваиваем СЧ
}
 
/// вывод матрицы на экран
void Print(int **matrix, const size_t rows, const size_t columns)
{
    for (size_t row=0; row < rows; row++)
    {
        for (size_t column=0; column < columns; column++)
            std::cout << matrix[row][column] << " "; // выводим элемент
        std::cout << std::endl; // перевод строки
    }
}
 
/// пример обработки матрицы - подсчет суммы всех элементов
int Sum(int **matrix, const size_t rows, const size_t columns)
{
    int sum = 0; // счётчик суммы
    for (size_t row=0; row < rows; row++)
        for (size_t column=0; column < columns; column++)
            sum += matrix[row][column];
 
    return sum; // вернуть результат
}
 
// ...
// сюда вставить все дополнительные функции которые напишете
// ...
 
 
int main()
{
    //setlocale(LC_ALL, "rus"); // установим локаль для вывода русских символов
 
    size_t rows, columns; // строки и столбцы
 
    // вводим размерность матрицы
    std::cout << "Введите количество строк матрицы: ";
    std::cin >> rows;
    std::cout << "Введите количество столбцов матрицы: ";
    std::cin >> columns;
 
    // выделяем память под матрицу
    int **matrix = new int*[rows];
    for (size_t row=0; row < rows; row++)
        matrix[row] = new int[columns];
 
    // заполнение случайными числами
    FillRandomNumbers(matrix, rows, columns);
 
    // вывод на экран
    std::cout << "\nМатрица:\n";
    Print(matrix, rows, columns);
 
    // обработка матрицы
    std::cout << "\nСумма всех элементов матрицы равна " << Sum(matrix, rows, columns) << std::endl;
 
    // освобождаем память, выделенную под матрицу
    // освобождение идёт в обратном порядке от выделения
    for (size_t row=0; row < rows; row++)
        delete[] matrix[row];
    delete[] matrix;
 
    // ждём нажатия клавиши перед выходом из приложения
    //system("pause");
}

#include <iostream>
#include <cstdlib>
using namespace std;
/**Определение структуры**/
struct SOTRUDNIK
{
    char SotFam[255];   //Фамилия сотрудника
    char SotName[255];  //Имя сотрудника
    short SotStag;      //Стаж сотрудника
    short SotAge;       //Возраст сотрудника
    char SotSex;        //Пол сотрудника
};
/**Вспомогательная процедура для обмена местами двух элементов**/
void swapvalue(SOTRUDNIK &s1,SOTRUDNIK &s2)
{
    SOTRUDNIK temp=s1;
    s1=s2;
    s2=temp;
}
/**Процедура вывода на экран информации.*
* параметр "param" указывает то, сотрудников каких возрастов выводить. Если параметр не указан, то выводятся все сотрудники
*/
void ShowInfo(SOTRUDNIK *sot, int N,short param=0)
{
    int col=0;      //вспомогательная переменная, описывающая кол-во найденных сотрудников указанного возраста
    if(param==0)
    {
        for(int i=0;i<N;i++)
        {
            for(int j=1;j<N-1;j++)
            {
                if(sot[i].SotStag<=sot[j].SotStag)
                    swapvalue(sot[i],sot[j]);
            }
        }
        cout<<"___INFO ABOUT ALL:___\n";
        for(int i=0;i<N;i++)
        {
            cout<<"FAMILIA: "<<sot[i].SotFam<<"\n";
            cout<<"NAME: "<<sot[i].SotName<<"\n";
            cout<<"STAG: "<<sot[i].SotStag<<"\n";
            cout<<"AGE: "<<sot[i].SotAge<<"\n";
            cout<<"POL: "<<sot[i].SotSex<<"\n";
        }
    }
    else
    {
        cout<<"___INFO ABOUT PEOPLE WITH AGE= "<<param<<":___\n";
        for(int i=0;i<N;i++)
        {
            if(sot[i].SotAge==param)
            {
                cout<<"FAMILIA: "<<sot[i].SotFam<<"\n";
                cout<<"NAME: "<<sot[i].SotName<<"\n";
                cout<<"STAG: "<<sot[i].SotStag<<"\n";
                cout<<"AGE: "<<sot[i].SotAge<<"\n";
                cout<<"POL: "<<sot[i].SotSex<<"\n";
                col++;
            }
        }
        if(col<1)
            cout<<"******NO INFO\n";
    }
}
/**Процедура ввода информации**/
void SetInfo(SOTRUDNIK *sot, int N)
{
    for(int i=0;i<N;i++)
    {
        cout<<"------------------\n";
        cout<<"FAMILIA:";cin.getline(sot[i].SotFam,255);cin.ignore();
        cout<<"NAME:";cin.getline(sot[i].SotName,255);cin.ignore();
        cout<<"STAG:";cin>>sot[i].SotStag;
        cout<<"AGE:";cin>>sot[i].SotAge;
        cout<<"POL:";cin>>sot[i].SotSex;cin.ignore();
    }
}
int main()
{
    int N=8;
    SOTRUDNIK *sotr=new SOTRUDNIK[N];
    SetInfo(sotr,N);
    ShowInfo(sotr,N);
    delete[]sotr;
    return 0;
}

// сборка: g++ -std=c++11 stack.cxx -o stack
#include <stdexcept>
#include <exception>
#include <iostream>
 
// шаблонный стек на основе односвязного списка
template<class Type>
class stack {
public:
    typedef Type value_type; // тип значения
    typedef value_type& value_ref; // ссылка на элемент
    typedef const value_type& value_cref; // константная ссылка
private:
    // структура "звено"
    struct node {
        value_type value; // значение
        node* link;  // указатель на следующий
        // конструктор по умолчанию
        node():value(0),link(nullptr){}
        // конструктор с установкой значений
        node(value_cref val, node* prev):value(val),link(prev){}
    };
    node*  m_head; // голова стека
public:
    // конструктор по умолчанию
    stack():m_head(nullptr),m_size(0){}
    // деструктор
    ~stack() { clear(); }
    // проверка на пустоту
    bool is_empty() { return nullptr == m_head; }
    // очистка стека
    void clear() {
        while(not is_empty()) {
            node* tmp = m_head;
            m_head = m_head->link;
            delete tmp;
        }
    }
    // возвращает значение на верхушке стека
    value_ref top() {
        if(is_empty())
            throw std::runtime_error("stack is empty");
        return m_head->value;
    }
    // добавление элемента
    void push(value_cref value) {
        // создаем звено
        node* tmp = new node(value, m_head); // при нехватке памяти
                                             // будет выброшено исключение std::bad_alloc
        // запоминаем новую голову
        m_head = tmp;
    }
    // удаляет верхний элемент
    void pop() {
        if(is_empty())
            throw std::runtime_error("stack is empty");
        // запоминаем голову
        node* tmp = m_head;
        // смещаемся к следующему
        m_head = m_head->link;
        // удаляем старую голову
        delete tmp;
    }
};
int main() {
    stack<int> st; // создаем стек
    // записываем данные
    for(int i = -5; i <= 5; ++i) {
        try {
            st.push(i);
        }
        catch(std::bad_alloc &e) {
            std::cerr << "Oops: " << e.what() <<std::endl;
            return 1;
        }
    }
    // выводим содержимое
    while(!st.is_empty()) {
        std::cout << st.top() << std::endl;
        st.pop();
    }
    return 0;
}

bool is_empty() const { /*...*/ }

#include <iostream>
#include <cmath>
#include <cstdlib>
double f(double x)
{
   double y;
    const double pi = 3.1415926535897932384626433832795;
 
    if ( x < 0 ) {
        // x < 0
        y = x * x - 3 - std::pow( pi - x, 1. / 3 );
    } else {
        double x2 = x * x + 3;
        if ( x >= 1 ) {
            // x >= 1
            y = x * x2 + std::log( pi + x );
        } else {
            // 0 <= x < 1
            y = x2 * x2 - std::sqrt( pi / 2 + x );
        }
    }
   return y;
}
 
int main()
{
    double x;
    std::cout << "Введите x: ";
    std::cin >> x;
 
    std::cout << "y = " << f(x) << std::endl;
    std::system( "pause" );
    return 0;
}

#include<iostream>
double kek(int n,double x,...);  // прототип функции
int main()
{
    std::cout <<"S="<<kek(8, 0.1, 0.2, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0)<<std::endl;
    //system("pause");
    return 0;
}
 
double kek(int n,double x,...)  // функция вычисляющая сумму параметров, первое число - их количество
{
   double* p = &x;    //установились на начало списка параметров
   double s = 0;
   for(int i=0;i<n;i++)
       s+=*(p++);
   return s;
}

#include <iostream>
 
// терминальная функция
double sum() { return 0; }
 
// функция с переменным числом аргументов
template <typename... R> 
double sum(double init, R... rest) {
    return init + sum(rest...);
}
 
int main() {
    // кол-во аргументов может быть любым 
    std::cout << sum(1, 2.1, 3, -1.5) << std::endl;
}

#include <initializer_list>
#include <iostream>
 
double sum(std::initializer_list<double> lst) {
    double res = 0; // лучше использовать std::accumulate
    for(double el : lst) {
        res += el;
    }
    return res;
}
 
int main() {
    std::cout << sum({1, 2.1, 3, -1.5}) << std::endl;
}

#include <iostream>
 
template <typename T>
class BinaryOperationBase
{
public:
    static double run(double left, double right)
    {
        return T::run(left, right);
    }
 
    void saveResult(double left, double right)
    {
        static_cast<T *>(this)->saveResult(left, right);
    }
 
    double getResult()
    {
        return static_cast<T *>(this)->getResult();
    }
};
 
class DoubleMult : public BinaryOperationBase<DoubleMult>
{
private:
    double result;
public:
    static double run(double left, double right)
    {
        return left * right;
    }
 
    void saveResult(double left, double right)
    {
        result = left * right;
    }
 
    double getResult()
    {
        return result;
    }
};
 
class DoubleSub : public BinaryOperationBase<DoubleSub>
{
private:
    double result;
public:
    static double run(double left, double right)
    {
        return left - right;
    }
 
    void saveResult(double left, double right)
    {
        result = left - right;
    }
 
    double getResult()
    {
        return result;
    }
};
 
int main()
{
    BinaryOperationBase<DoubleMult> *mult = new DoubleMult();
    BinaryOperationBase<DoubleSub> *sub = new DoubleSub();
 
    std::cout << BinaryOperationBase<DoubleMult>::run(20.5, 10.0) << '\n';  
    std::cout << BinaryOperationBase<DoubleSub>::run(20.5, 10.0) << "\n\n"; 
 
    mult->saveResult(-120.3, -3.3);
    sub->saveResult(-120.3, -3.3);
    std::cout << mult->getResult() << ' ' << sub->getResult() << "\n\n";
 
    return 0;
}

#include <iostream>
 
namespace Constants {
    const size_t FibSize = 32;
}
 
template<int t> struct Elem {
    static const size_t value = Elem<t - 1>::value + Elem<t - 2>::value;
};
template<> struct Elem<0> {
    static const size_t value = 0;
};
template<> struct Elem<1> {
    static const size_t value = 1;
};
template<int r, int t> struct Table : Table<r + 1, t - 1> {
    Table() { values[t] = Elem<t>::value; }
};
template<int r> struct Table<r, 0> {
    size_t values[r + 1];
    Table() { values[0] = Elem<0>::value; }
    const size_t& operator[](int i) const { return values[i]; }
};
 
typedef Table<0, Constants::FibSize> Fibonachi;
 
int main(int argc, char *argv[]) {
    Fibonachi fArray;
 
    for (size_t i(0); i < Constants::FibSize; ++i)
        std::cout << fArray[i] << std::endl;
 
    std::cin.ignore();
    return 0;
}