sparse matrix class implementation

Hi,
I code class to storage sparse matrix row compressed and i have a
problem with implements method to setVal and addVal.
I will replace later this methods overloaded operator().
Please, can You help me?
Thanks in advance.

I write this, but it's not so good :(

#include <iostream>
#include <vector>

using namespace std;

template <class T>
class SparseMatrixCR {
    public:
        SparseMatrixCR() {}
        SparseMatrixCR(size_t m, size_t n) : rows_(m),
cols_(n) {
            row_ptr.resize(m+1);
        }

        // read
        T operator()(size_t row, size_t col) const;
        // write
        T& operator()(size_t row, size_t col);

        int setSize(size_t _size);
        void setVal(size_t row, size_t col, T val);
        void addVal(size_t row, size_t col, T val);

        // -- friend func --
        friend ostream& operator<< (ostream& os, const
SparseMatrixCR<T>& rha) {
            // os << "[" << rha.GetRows() << "][" <<
rha.GetCols() << "]" << endl;

            for(size_t i(0); i < rha.GetRows(); ++i) {
                for(size_t j(0); j < rha.GetCols();
++j) {
                    os.setf(ios::scientific,
ios::floatfield);
                    os.width(14);
                    os << rha(i, j) << " ";
                }
                os << endl;
            }
            return os;
        }

    private:
        vector< T > values;
        vector< size_t > row_ptr;
        vector< size_t > colidx;

        size_t rows_;
        size_t cols_;

}; // end of: class SparseMatrixCR

template <class T>
void SparseMatrixCR<T>::setVal(size_t row, size_t col, T val) {

    if(val != 0 && values.size() == 0) {
        colidx.push_back(col);
        values.push_back(val);
        for(size_t i(row+1); i < row_ptr.size(); ++i) {
            row_ptr[i] += 1;
        }
    }
    else {

        bool exist(false);

        for(size_t idx(row_ptr[row]); idx < row_ptr[row+1];
++idx) {
            if(colidx[idx] == col) {
                values[idx] = val;
                exist = true;
                break;
            }

        }
        if(exist == false) {
            if(val != 0) {
                colidx.insert( colidx.begin() +
row_ptr[row], col );
                values.insert( values.begin() +
row_ptr[row], val );
                for(size_t i(row+1); i <
row_ptr.size(); ++i) {
                    row_ptr[i] += 1;
                }
            }
            else {
                colidx.erase( colidx.begin() +
row_ptr[row] );
                values.erase( values.begin() +
row_ptr[row] );
                for(size_t i(row+1); i <
row_ptr.size(); ++i) {
                    row_ptr[i] -= 1;
                }
            }
        }
    }

} // end of: setVal()

template <class T>
void SparseMatrixCR<T>::addVal(size_t row, size_t col, T val) {

    if(values.size() == 0) {
        colidx.push_back(col);
        values.push_back(val);
        for(size_t i(row+1); i < row_ptr.size(); ++i) {
            row_ptr[i] += 1;
        }
    }
    else {

        bool exist(false);

        for(size_t idx(row_ptr[row]); idx < row_ptr[row+1];
++idx) {
            if(colidx[idx] == col) {
                values[idx] += val;
                exist = true;
                break;
            }
            if(colidx[idx] > col) {
                poz = idx;
            }
        }
        if(exist == false) {
            if(val != 0) {
                colidx.insert( colidx.begin() +
row_ptr[row], col );
                values.insert( values.begin() +
row_ptr[row], val );
                for(size_t i(row+1); i <
row_ptr.size(); ++i) {
                    row_ptr[i] += 1;
                }
            }
        }
    }
} // end of: addVal()