Матрица..

//простейший пример
#include "stdafx.h"
#include <iostream.h>
 
class matrix//создания класа matrix
{
public:
    matrix(){};
    matrix(int f[3][3]) {matr=f;}//конструктор для заполениния матрици
    int matr[3][3];// клас содержит двумерный массив выступающий матрицей
};
matrix funk(matrix);
 
int main()
{
    int a[3][3]={0};
    matrix g(a);//создается обьект класса
    g=funk(g);
    return 0;
}
 
matrix funk(matrix a)
{
    //ваши вычисления
    return a;
}

class cmatrx
{
public:
        cmatrx(){};
        cmatrx(int f[m][m]) {matr=f;}
        int matr[m][m];
};
 
{
 
cmatrx func(int array[m][m], int A[m][m], int e[m][m],int n, int *N)
    {
    if (n=N) return 1;
    B[m][m]=m_matr(array[m][m],A[m][m]);
 
    return array[m][m]+func(B[m][m], A[m][m], e[m][m], n+1, &N)
 
    }
 
 
 
}
 
 
cmatrx m_matr(A[m][m], B[m][m])
{
int i, j;
for(i=0;i<N;i++)   
    {
     for(j=0;j<N;j++) 
        {
                B(i,j)=0;
                for(k=0;k<N;k++)
            {
                     C(i,j)+=A(i,k)*B(k,j);
                }
            }
    }
}

/////////////////////////////////////////////////////////////////////////////
// Дана матрица А порядка m, и натуральное число n, надо вычислить 
// E + A + A^2 + ..... + A^n с помощью рекурсии.
/////////////////////////////////////////////////////////////////////////////
#include <vector>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <iomanip>
/////////////////////////////////////////////////////////////////////////////
class T_kvadr_matrix
{
    typedef double               T_elem;
    typedef std::vector<T_elem>  T_row;
    typedef std::vector<T_row>   T_tabl;
    //-----------------------------------------------------------------------    
    T_tabl                       tabl_;
    //-----------------------------------------------------------------------    
public:
    //-----------------------------------------------------------------------    
    T_kvadr_matrix(int dim) : tabl_(dim, T_row(dim))
    {}
    //-----------------------------------------------------------------------    
    void input()
    {
        std::cout << "Введите матрицу порядка "   
                  << dim()
                  << ":"
                  << std::endl;
 
        for(size_t i = 0; i < dim(); ++i)
        {
            for(size_t j = 0; j < dim(); ++j)
            {
                std::cout << "A("
                          << i
                          << ", "
                          << j
                          << ") = ";                
                std::cin >> (*this)(i, j);
            }
            std::cout << std::endl;
        }
    }
    //-----------------------------------------------------------------------
    T_kvadr_matrix  operator+ (const T_kvadr_matrix&  M) const
    {
        if(dim() != M.dim())
        {
            std::cout << "Не совпадают размерности складываемых матриц."
                      << std::endl;
            exit(EXIT_FAILURE);
        }
        T_kvadr_matrix  res_matr(dim());
 
        for(size_t  i = 0; i < dim(); ++i)
        {
            std::transform(get_row(i).begin(), get_row(i).end(),
                           M.get_row(i).begin(),
                           res_matr.get_row(i).begin(), std::plus<T_elem>());
        }
 
        return  res_matr;
    }    
    //-----------------------------------------------------------------------
    T_kvadr_matrix  operator* (const T_kvadr_matrix&  M) const
    {
        if(dim() != M.dim())
        {
            std::cout << "Не совпадают размерности перемножаемых матриц."
                      << std::endl;
            exit(EXIT_FAILURE);
        }
        T_kvadr_matrix  res_matr(dim());
        T_kvadr_matrix  M_transp(M.get_transp());
        for(size_t  i = 0; i < dim(); ++i)
        {            
            for(size_t  j = 0; j < dim(); ++j)
            {        
                res_matr(i, j)
                    = std::inner_product(get_row(i).begin(), get_row(i).end(),
                                         M_transp.get_row(j).begin(), T_elem());
 
            }            
        }
        return  res_matr;
    }
    //-----------------------------------------------------------------------
    T_kvadr_matrix  E()
    {
        T_kvadr_matrix  res_matr(dim());
        for(size_t i = 0; i < res_matr.dim(); ++i)
        {            
            res_matr(i, i) = 1;
        }
        return  res_matr;
    }
    //-----------------------------------------------------------------------
    void  print() const
    {
        for(size_t i = 0; i < dim(); ++i)
        {
            for(size_t j = 0; j < dim(); ++j)
            {
                std::cout << std::setprecision(4)
                          << std::setw(12)                          
                          << (*this)(i, j);                          
            }            
            std::cout << std::endl;
            std::cout << std::endl;
        }            
    }
    //-----------------------------------------------------------------------
    T_kvadr_matrix  get_transp() const
    {
        T_kvadr_matrix  res_transp(dim());
        for(size_t  i = 0; i < dim(); ++i)
        {
            for(size_t  j = 0; j < dim(); ++j)
            {                
                res_transp(i, j) = (*this)(j, i);
            }            
        }
        return  res_transp;
    }
    //-----------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------
    size_t dim() const
    {
        return tabl_.size();
    }
    //-----------------------------------------------------------------------
    T_elem  operator () (size_t i, size_t j) const
    {
        return tabl_[i][j];
    }
    //-----------------------------------------------------------------------
    T_elem&  operator () (size_t i, size_t j)
    {
        return tabl_[i][j];
    }
    //-----------------------------------------------------------------------
    const T_row&  get_row(int i) const
    {
        return tabl_[i];
    }
    //-----------------------------------------------------------------------
    T_row&  get_row(int i) 
    {
        return tabl_[i];
    }
    //-----------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////
std::ostream& operator<<(std::ostream& os, const T_kvadr_matrix& M)
{
    M.print();
    return os;
}
/////////////////////////////////////////////////////////////////////////////
std::istream& operator>>(std::istream& is, T_kvadr_matrix& M)
{
    M.input();
    return is;
}
/////////////////////////////////////////////////////////////////////////////
T_kvadr_matrix  matr_polinom(T_kvadr_matrix A, int stepen)
{
    return stepen == 0 ? A.E() : A.E() + A * matr_polinom(A, stepen - 1);
}
/////////////////////////////////////////////////////////////////////////////
 
int main()
{
    std::locale::global(std::locale(""));   
    int m;
    do
    {
        std::cout << "Введите размерность марицы: m = ";
        std::cin >> m;
    }while(m <= 0);
    
    T_kvadr_matrix  A(m);
    std::cin >> A;    
    std::cout << "Введенная матрица A:"
              << std::endl
              << A;    
    int n;
    do
    {
        std::cout << "Введите степень матричного полинома: n = ";
        std::cin >> n;
    }while(n < 0);
 
    if(n == 0)
    {
        std::cout << "Значение матричного полинома A^0 равно:";   
    }
    else if(n == 1)
    {
        std::cout << "Значение матричного полинома A^0 + A^1 равно:";   
    }
    else
    {
        std::cout << "Значение матричного полинома A^0 + A^1 + ... + A^"
                  << n
                  << " равно:";    
    }    
    std::cout << std::endl
              << matr_polinom(A, n);             
    return 0;
}