delete внутри класса для самого класса

#ifndef __PROGTEST__
#include <iostream>
#include <sstream>
#include <iomanip>
#endif /* __PROGTEST__ */
 
class CRow {
public:
 
    CRow() {
        RowSize = 0;
    };
 
    CRow(int Cols) {
        RowElements = new double [Cols];
        for (int i = 0; i < Cols; i++) {
            RowElements[i] = 0.0;
        }
        RowSize = Cols;
    };
 
    CRow & operator=(const CRow & Old) {
        if (this == &Old) {
            return *this;
        }
        RowSize = Old.RowSize;
        RowElements = new double[Old.RowSize];
        for (int i = 0; i < Old.RowSize; i++) {
            RowElements[i] = Old.RowElements[i];
        }
        //std::cout << "padla" << std::endl;
        return *this;
    };
 
    ~CRow() {
        //std::cout << "padla" << std::endl;
        delete [] RowElements;
    };
 
 
    double & operator[](const int & ColNumber)const {
        return RowElements[ColNumber];
    };
 
    friend std::ostream & operator<<(std::ostream& os, const CRow& Row) {
        os << Row.RowElements[0];
        for (int i = 1; i < Row.RowSize; i++) {
            os << ", " << Row.RowElements[i];
        }
        return os;
    };
    friend class CMatrix;
protected:
    double * RowElements;
    int RowSize;
};
 
class CMatrix {
public:
 
    CMatrix(int RCount, int ColsCount) {
        Rows = new CRow*[RCount];
        for (int i = 0; i < RCount; i++) {
            Rows[i] = new CRow(ColsCount);
        }
        RowsCount = RCount;
        ColumnsCount = ColsCount;
    };
 
    CMatrix(const CMatrix & Old) : RowsCount(Old.RowsCount), ColumnsCount(Old.ColumnsCount) {
        Rows = new CRow*[Old.RowsCount];
        for (int i = 0; i < RowsCount; i++) {
            Rows[i] = new CRow;
            *Rows[i] = *Old.Rows[i];
        }
    };
 
    ~CMatrix() {
        for (int i = 0; i < RowsCount; i++) {
            delete Rows[i];
        }
        delete [] Rows;
    };
 
    friend std::ostream & operator<<(std::ostream& os, const CMatrix& CM) {
        for (int i = 0; i < CM.RowsCount - 1; i++) {
            os << "{" << *CM.Rows[i] << " }," << std::endl;
        }
        os << "{" << *CM.Rows[CM.RowsCount - 1] << "}" << std::endl;
        return os;
    };
    CRow & operator[](const int & RowNumber)const {
        return *Rows[RowNumber];
    };
    friend class CRow;
 
    friend std::istream & operator>>(std::istream& is, CMatrix& CM) {
        int RowSize = 0;
        int LinesCount = 0;
        int ColsTmp = 0;
        double d;
        char c;
        bool WhileBool = true;
        States state = State_StartMatrix;
        while (WhileBool) {
            switch (state) {
                case State_StartMatrix:
                    is >> std::skipws >> c;
                    if (c == '{') {
                        state = State_StartLine;
                    } else {
                        state = State_Error;
                    }
                    break;
                case State_StartLine:
                    is >> std::skipws >> c;
                    if (c == '{') {
                        state = State_NextNumber;
                    } else {
                        state = State_Error;
                    }
                    break;
                case State_NextNumber:
                    is >> std::skipws >> d;
                    if (!is.fail()) {
                        //RowElements[LinesCount][ColsTmp] = d;
                        ColsTmp++;
                        //cout << "num: '" << d << "'" << endl;
                        state = State_GotNumber;
                    } else {
                        state = State_Error;
                    }
                    break;
                case State_GotNumber:
                    is >> std::skipws >> c;
                    if (c == ',') {
                        state = State_NextNumber;
                    } else if (c == '}') {
                        state = State_EndLine;
 
                    } else {
                        state = State_Error;
                    }
                    break;
                case State_EndLine:
                    LinesCount++;
                    if (LinesCount > 1) {
                        if (RowSize != ColsTmp) {
                            state = State_Error;
                            break;
                        }
                    }
                    if (LinesCount == 1) {
                        RowSize = ColsTmp;
                    }
                    ColsTmp = 0;
                    is >> std::skipws >> c;
                    if (c == ',') {
                        state = State_StartLine;
                    } else if (c == '}') {
                        state = State_EndMatrix;
                    } else {
                        state = State_Error;
                    }
                    break;
                case State_EndMatrix:
                    WhileBool = false;
                    break;
                case State_Error:
                    is.setstate(std::ios::failbit);
                    WhileBool = false;
                    break;
            }
        }
 
        if (!is.fail()) {
 
 
            //            for (int i = 0; i < LinesCount; i++) {
            //                for (int j = 0; j < RowSize - 1; j++) {
            //                    std::cout << "" << RowElements[i][j] << ",";
            //                }
            //                std::cout << "" << RowElements[i][RowSize - 1] << "";
            //                std::cout << std::endl;
            //            }
            //            std::cout << "Rows:\t" << LinesCount << std::endl;
            //            std::cout << "Cols:\t" << RowSize << std::endl;
 
 
            CMatrix *tmpMatrix = new CMatrix(LinesCount, RowSize);
            is.seekg(0, is.beg);
            LinesCount = 0;
            RowSize = 0;
            ColsTmp = 0;
 
 
            bool WhileBool = true;
            States state = State_StartMatrix;
            while (WhileBool) {
                switch (state) {
                    case State_StartMatrix:
                        is >> std::skipws >> c;
                        if (c == '{') {
                            state = State_StartLine;
                        } else {
                            state = State_Error;
                        }
                        break;
                    case State_StartLine:
                        is >> std::skipws >> c;
                        if (c == '{') {
                            state = State_NextNumber;
                        } else {
                            state = State_Error;
                        }
                        break;
                    case State_NextNumber:
                        is >> std::skipws >> d;
                        if (!is.fail()) {
                            //RowElements[LinesCount][ColsTmp] = d;
                            tmpMatrix->Rows[LinesCount]->operator [](ColsTmp) = d;
                            ColsTmp++;
                            //cout << "num: '" << d << "'" << endl;
                            state = State_GotNumber;
                        } else {
                            state = State_Error;
                        }
                        break;
                    case State_GotNumber:
                        is >> std::skipws >> c;
                        if (c == ',') {
                            state = State_NextNumber;
                        } else if (c == '}') {
                            state = State_EndLine;
                        } else {
                            state = State_Error;
                        }
                        break;
                    case State_EndLine:
                        LinesCount++;
                        if (LinesCount > 1) {
                            if (RowSize != ColsTmp) {
                                state = State_Error;
                                break;
                            }
                        }
                        if (LinesCount == 1) {
                            RowSize = ColsTmp;
                        }
                        ColsTmp = 0;
                        is >> std::skipws >> c;
                        if (c == ',') {
                            state = State_StartLine;
                        } else if (c == '}') {
                            state = State_EndMatrix;
                        } else {
                            state = State_Error;
                        }
                        break;
                    case State_EndMatrix:
                        WhileBool = false;
                        break;
                    case State_Error:
                        is.setstate(std::ios::failbit);
                        WhileBool = false;
                        break;
                }
            }
 
 
 
            for (int i = 0; i < CM.RowsCount; i++) {
                delete CM.Rows[i];
            }
            delete [] CM.Rows;
 
            
            CM = *tmpMatrix;
 
            return is;
        }
        return is;
    };
 
 
 
protected:
    CRow ** Rows;
 
    enum States {
        State_StartMatrix,
        State_StartLine,
        State_EndLine,
        State_EndMatrix,
        State_GotNumber,
        State_NextNumber,
        State_Error
    };
    int RowsCount;
    int ColumnsCount;
};
 
int main(int argc, char** argv) {
    std::istringstream is;
    std::ostringstream os;
 
 
    CMatrix a(2, 3);
    a[0][0] = 1;
    a[0][1] = 2;
    a[0][2] = 3;
    a[1][0] = 4;
    a[1][1] = 5;
    a[1][2] = 6;
    const CMatrix b = a;
    std::cout << b[1][2] << std::endl;
 
    CMatrix d(1, 1);
    d[0][0] = -1;
 
    std::cout << d;
 
 
 
 
    is . clear();
    is . str("{ { 1.1782, 2, 3, 4 }, { 4, 3, 2, 1 } } ");
 
 
    is >> a;
 
 
    return 0;
}