Наследование классов(ошибка неразрешенные внешние символы)

class Create_Matrix
{
    protected:
        int stroka; // Количество строк.
        int temp_var; // Переменная для мелких нужд.
        double **A; // Матрица А.
        double **Rashir_matrix; // Расширенная матрица.
        double *X; // Вектор решения матрицы.
        double *B; // Вектор свободных членов.
    
    public: 
        Create_Matrix(); // Стандартный конструктор.
        Create_Matrix(int); // Конструктор матриц и векторов.
        ~Create_Matrix(); // Деструктор матриц и векторов.
        void zeros_matrix(); // Обнуление матриц и векторов.        
        void push_data(); // Чтение из файла.
        void test_push_data(); // Проверка равенства количества ячеек в матрице и прочитанных из файла.
        void insert_data(); // Ввод с клавиатуры.        
        void setMatrix_Size(int); // Получение размерности матрицы.
        void getMatrix_on_screen(); // Вывод матриц. 
};
 
class Gauss: public Create_Matrix
{
    protected:
        double Aij; // Число, используемое при вычитание строк.
        double delitel; // Делитель для приведения матрицы к ступенчатому виду.
 
    public:
        Gauss();
        void stupenchatii_vid(); // Приведение к ступенчатому виду.
        void proverka(); // Проверка на единственность решения.  
        void reshenie(); // Нахождения корней уравнений.
        void reshenie_on_screen(); // Вывод корней на экран.
};

/////////////////////////////////////////////////////////////////////////////////
////////////////////////////// Create_Matrix ////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
 
Create_Matrix::Create_Matrix(int read_stroka) // Конструктор матриц и векторов.
{
    setMatrix_Size(read_stroka); 
 
    A = new double *[stroka]; // Количество строк для матрицы А и расширенной.
    Rashir_matrix = new double *[stroka];
    X = new double [stroka]; // Создание векторов X и B.
    B = new double [stroka];
 
    for(int i = 0; i < stroka; i++) // Столбцы для матрциы A.
    {
        A[i] = new double [stroka];
    }
    for(int i = 0; i < stroka + 1; i++) // Столбцы для расширенной матрицы.
    {
        Rashir_matrix[i] = new double [stroka + 1];
    }
    zeros_matrix(); // Обнуляем матрицы.
}
 
Create_Matrix::~Create_Matrix() // Деструктор матриц и векторов.
{
    for(int i = 0; i < stroka; i++)
    {
        delete [] A[i];
        delete [] Rashir_matrix[i];
    }       
    delete [] X;
    delete [] B;
}
 
void Create_Matrix::zeros_matrix() // Обнуление матриц и векторов.
{
    for(int i = 0; i < stroka; i++) // Матрица А.
    {
        for(int j = 0; j < stroka; j++)
        {
            A[i][j] = 0;
        }
    }
    for(int i = 0; i < stroka; i++) // Расширенная матрица.
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            Rashir_matrix[i][j] = 0;
        }
    }
    for(int i = 0; i < stroka; i++) // Вектора X и B.
    {
        B[i] = 0;
        X[i] = 0;
    }
}
 
void Create_Matrix::push_data() // Чтение из файла.
{
    read_data Matrix; // Открытие и чтение файла.
    Matrix.Reading();
    temp_var = 0; // Счетчик для массива.
    for(int i = 0; i < stroka; i++) // Распределение чисел в матрицы и в вектор свободных членов.
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            Rashir_matrix[i][j] = Matrix.data[temp_var];
            if(j != stroka)
            {
                A[i][j] = Matrix.data[temp_var];
            }
            else
            {
                B[i] = Matrix.data[temp_var];
            }
            temp_var += 1;
        }
    }
 
    if(Matrix.data.size() != stroka*(stroka + 1)) // Проверка равенства количества ячеек.
    {
        cout << "Размер прочитанной матрицы не соответствует введенному размеру." << endl;
        cout << "Выполнение программы завершено." << endl << endl;
        system("pause");
        exit(0);
    }
}
 
void Create_Matrix::test_push_data()
{
    read_data Matrix;
 
}
void Create_Matrix::insert_data() // Ввод с клавиатуры.
{
    for(int i = 0; i < stroka; i++)
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            cin >> Rashir_matrix[i][j];
            if(j != stroka)
            {
                A[i][j] = Rashir_matrix[i][j];
            }
            else
            {
                B[i] = Rashir_matrix[i][j];
            }
        }
    }
}
 
void Create_Matrix::setMatrix_Size(int read_stroka) // Получение размерности матрицы.
{
    stroka = read_stroka;
}
 
void Create_Matrix::getMatrix_on_screen() // Вывод матриц.
{
    cout << "Матрица A: " << endl;
    for(int i = 0; i < stroka; i++)
    {
        for(int j = 0; j < stroka; j++)
        {
            cout << A[i][j] << " ";
        }
    cout << endl;
    }
    cout << endl;
    cout << "Вектор B: " << endl;
    for(int i = 0; i < stroka; i++)
    {
        cout << B[i] << endl;
    }
    cout << endl;
    cout << "Расширенная матрица: " << endl;
    for(int i = 0; i < stroka; i++)
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            cout << Rashir_matrix[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}
 
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////// Gauss ////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
 
Gauss::Gauss()
{
    void stupenchatii_vid(); // Приведение к ступенчатому виду.
    void proverka(); // Проверка на единственность решения.  
    void reshenie(); // Нахождения корней уравнений.
    void reshenie_on_screen(); // Вывод корней на экран.
}
 
void Gauss::stupenchatii_vid()
{
    for(int i = 0; i < stroka; i++) // Цикл преобразования матрицы.
    {
        delitel = Rashir_matrix[i][i];
            for(int j = 0; j < stroka + 1; j++) // Создание диагонали, состоящей из единиц.
        {
            Rashir_matrix[i][j] =  Rashir_matrix[i][j]/delitel;
        }
 
        for(int z = i; z < stroka; z++) // Обнуление столбцов.
        {
            Aij = Rashir_matrix[z + 1][i];
            for(int j = 0; j < stroka + 1; j++)
            {
                Rashir_matrix[z + 1][j] = Rashir_matrix[z + 1][j] - Rashir_matrix[i][j]*Aij;
            }
        }
    }
}
 
void Gauss::proverka()
{
    if(Rashir_matrix[stroka][stroka] == 0) // Проверка наличия единственного решения.
    {
        cout << "Данная система имеет бесконечное множество решений. Выполнение программы завершено." << endl;
        system("pause");
        exit(0);
    }
}
        
void Gauss::reshenie()
{
    for(int i = 0; i < stroka; i++) // Перезапись данных из расширенной матрицы в матрицу А и вектор B.
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            if(j != stroka)
            {
                A[i][j] = Rashir_matrix[i][j];
            }
            else
            {
                B[i] = Rashir_matrix[i][j];
            }
        }
    }
    
    for(int i = stroka - 1; i >= 0; i--) // Нахождение решения - вектор X.
    {
        X[stroka-1] = B[stroka-1]/A[stroka-1][stroka-1];
        double sum = 0; // Переменная для нахождения корней.
        for(int j = stroka - 1; j >= 0; j--)
        {
            sum += A[i][j]*X[j];
        }
        X[i] = (B[i] - sum)/A[i][i];
    }
}
 
void Gauss::reshenie_on_screen()
{
    cout << endl;
    cout << "Преобразованная расширенная матрица: " << endl;           
    for(int i = 0; i < stroka; i++) // Вывод расширенной матрицы после обнуления.
    {
        for(int j = 0; j < stroka + 1; j++)
        {
            cout << Rashir_matrix[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
    cout << "Корни уравнения: " << endl;
    for(int i = stroka - 1; i >= 0; i--)
    {
        cout << X[i] << endl;
    }
}

int main()
{
    setlocale(LC_CTYPE, "rus"); // Поддержка кириллицы.
 
    int razmer; // Размер матрицы.
    int choose; // Выбор ввода.
    cout << "/////////////////// Программа для решения СЛАУ методом Гаусса /////////////////" << endl << endl;
    cout << "Введите размерность матрицы N*N: ";
    cin >> razmer;
    cout << endl;
 
    Create_Matrix Create_Matrix(razmer);
 
    
    cout << "Загрузить матрицу из файла или ввести с клавиатуры? "<< endl;
    cout << "(Матрицу записывать в расширенном виде). " << endl << endl;
    cout << "1 - прочитать из файла." << endl;
    cout << "2 - ввести с клавиатуры." << endl << endl;
 
    do // Проверка ввода.
    {
        cout << "Ваш выбор: ";
        cin >> choose;
        if(choose != 1 && choose != 2)
        {
            cout << endl;
            cout << "Ошибка. Повторите ввод. " << endl << endl;
        }
    }
    while(choose != 1 && choose != 2);
    cout << endl;
 
    if(choose == 1) // Чтение из файла.
    {
        Create_Matrix.push_data();
    }
    else // Ввод с клавиатуры.
    {
        cout << "Введите вашу расширенную матрицу построчно:" << endl << endl;
        Create_Matrix.insert_data();
    }
    cout << endl;
 
    Create_Matrix.getMatrix_on_screen();
 
    Gauss Gauss();
 
    Create_Matrix.~Create_Matrix();
 
    system("pause");
    return 0;
}

delete [] Rashir_matrix;
delete [] A;

Create_Matrix Create_Matrix(razmer);

Gauss Gauss();

Create_Matrix.~Create_Matrix();

for(int i = 0; i < stroka; i++) // Матрица А.
    {
        for(int j = 0; j < stroka; j++)
        {
            A[i][j] = 0;
        }
    }
 
--------------
это 
memset(array, 0, sizeof(array[0][0]) * size * size);
-----
а вообще Вы этот метод используете только при инициализации. зачем он вам?
инициализируйте сразу нулями
new double[size]();