使用模板在C 中復制建構式的問題-有解無憂

自從我上次用 C/C 寫東西以來已經十多年了，現在我遇到了一個我無法解決的問題。基本上我有兩個類，比如 CA 和 CB，其中CA 看起來像一個向量，而CB 看起來像一個二維矩陣。

我面臨的問題是我想構造一個 CB 型別的物件，并通過使用另一個 CB 型別的物件來實作。因此，我將一個已正確初始化的 CB 型別的物件作為引數傳遞，但是當我這樣做時，我得到一個錯誤的形式./B.h:97:43: error: no viable overloaded operator[] for type 'const CB<double>'。

我復制物件的方式是依靠 CA 類的復制機制。話雖如此，通過使用 CA 類的另一個初始化物件來構造 CA 類的物件似乎作業正常。所以，我有點迷失了什么是錯的。對于我的錯誤，我還從編譯器獲得了額外的幫助，但我不確定如何真正解決問題。我使用 g 收到的完整錯誤如下：

In file included from main.cpp:1:
./B.h:97:43: error: no viable overloaded operator[] for type 'const CB<double>'
        (*theRows)[i] = new CA <DataType>(m[i]);
                                          ^ ~
./B.h:105:2: note: in instantiation of member function 'CB<double>::copy' requested here
        copy(a);
        ^
main.cpp:24:16: note: in instantiation of member function 'CB<double>::CB' requested here
    CB<double> myPrecious(mycb_c);
               ^
./B.h:21:27: note: candidate function not viable: 'this' argument has type 'const CB<double>', but method is not marked const
    virtual CA<DataType>& operator[] (int index);
                          ^
1 error generated.

一定有什么我不記得該怎么做，或者很可能，我不知道。請注意，如果您使用 command 注釋來自 m main.cpp 的違規行（第 24 行）CB<double> myPrecious(mycb_c);，則程式編譯沒有問題并且輸出正常。

我試圖創建一個最小的示例，這是我可以縮小代碼的范圍。

關于如何使用復制使建構式作業的任何想法？我很感激你的時間。

以下是檔案

主.cpp：

#include "B.h"

int main()
{
    CA<double> myca_a(3);
    CA<double> myca_b(myca_a);
    
    CB<double> mycb_c(2, 3, 3.0);
    CB<double> mycb_d(3, 2, 4.0);
    CB<double> mycb_e;
    
    cout << "<separator>" << endl;
    cout << myca_a << endl;
    cout << "<separator>" << endl;
    cout << myca_b << endl;
    cout << "<separator>" << endl;
    cout << mycb_c << endl;
    cout << "<separator>" << endl;
    cout << mycb_d << endl;
    cout << "<separator>" << endl;
    cout << mycb_e << endl;
    cout << "<separator>" << endl;
    
    CB<double> myPrecious(mycb_c);

    return 0;
}

啊：

#include <iostream>
using namespace std;

template <class DataType>
class CA
{
protected:
    DataType* paDataType;
    int _size;
    void copy(const CA<DataType>& ac);

public:
    CA();
    CA(int n);
    CA(int n, const DataType& o);
    CA(const CA<DataType>& ac);
    virtual ~CA();

    int size() const;
    DataType& operator [] (int k);
    void operator= (const CA<DataType>& ac);
    friend ostream& operator<<(ostream& os, CA<DataType>& a) {
        os << "[";
        for (int i = 0; i < a.size() - 1; i  )
            os << a[i] << " ";
        os << a[a.size() - 1] << "]";
        return os;
    }
};


//Empty constructor
template <class DataType>
CA<DataType>::CA()
{
    paDataType = new DataType[1];
    _size = 1;
}

//Constructor
template <class DataType>
CA<DataType>::CA(int n)
{
    paDataType = new DataType[n];
    _size = n;
}

//Constructor w/ value
template <class DataType>
CA<DataType>::CA(int n, const DataType& o)
{
    paDataType = new DataType[n];
    _size = n;
    for (int i = 0; i < _size; i  ) paDataType[i] = o;
}

//Copy Constructor
template <class DataType>
CA<DataType>::CA(const CA<DataType>& ac)
{
    copy(ac);
}

//Copy method
template <class DataType>
void CA<DataType>::copy(const CA<DataType>& ac)
{
    paDataType = new DataType[ac._size];
    _size = ac._size;
    
    for (int i = 0; i < _size; i  )
        paDataType[i] = ac.paDataType[i];
}

//Destructor
template<class DataType>
CA<DataType>::~CA()
{
    if (paDataType != NULL)
        delete[] paDataType;
    paDataType = NULL;
    _size = 0;
}

//Size method
template <class DataType>
int CA<DataType>::size() const
{
    return _size;
}

//Accessor
template <class DataType>
DataType& CA<DataType>::operator [] (int k)
{
    return paDataType[k];
}

//Overloaded assignment operator
template <class DataType>
void CA<DataType>::operator= (const CA<DataType>& ac)
{
    if (paDataType != NULL) delete[] paDataType;
    copy(ac);
}

乙：

#include "A.h"

template <class DataType>
class CB : public CA <CA <DataType> >
{
protected:
    CA < CA<DataType>* >* theRows;
    void copy(const CB<DataType>& m);
    void deleteRows();

public:
    CB();
    CB(int n, int m);
    CB(int n, int m, DataType v);
    CB(const CB& a);
    virtual ~CB();
    void operator= (const CB<DataType>& a);
    virtual int size() const;
    int columns();
    int rows();
    virtual CA<DataType>& operator[] (int index);
    friend ostream& operator<<(ostream& os, CB<DataType>& m) {
        
        int rows = m.rows();
        int cols = m.columns();
        os << "----------" << endl;
        for (int i = 0; i < rows-1; i  ) {
            for (int j = 0; j < cols-1; j  ) {
                os << m[i][j] << " ";
            }
            os << m[i][cols-1] << endl;
        }
        for (int j = 0; j < cols-1; j  ) {
            os << m[rows-1][j] << " ";
        }
        os << m[rows-1][cols-1] << endl;
        os << "----------";

        return os;
    }
};

template <class DataType> CB<DataType>::CB() {
    theRows = new CA <CA <DataType>* >(1, NULL);
    (*theRows)[0] = new CA <DataType>();
}

template <class DataType>
CB<DataType>::CB(int n, int m)
{
    theRows = new CA <CA <DataType>* >(n, NULL);
    for (int i = 0; i < n; i  )
    {
        (*theRows)[i] = NULL;
        (*theRows)[i] = new CA <DataType>(m);
    }
}

template <class DataType>
CB<DataType>::CB(int n, int m, DataType v)
{
    theRows = new CA <CA <DataType>* >(n, NULL);
    for (int i = 0; i < n; i  )
    {
        (*theRows)[i] = new CA <DataType>(m, v);
    }
}

template <class DataType>
void CB<DataType>::deleteRows()
{
    if (theRows != NULL) 
    { 
        for (int i = 0; i < theRows->size(); i  ) 
        { 
            if ((*theRows)[i] != NULL) delete (*theRows)[i];        
            (*theRows)[i] = NULL; 
        }
        delete theRows; 
    }   
    theRows = NULL;
}

template <class DataType>
CB<DataType>::~CB()
{
    deleteRows();
}

template <class DataType>
void CB<DataType>::copy(const CB<DataType>& m)
{
    deleteRows();
    theRows = new CA <CA <DataType>* >(m.size(), NULL);
    for (int i = 0; i < m.size(); i  )
    {
        (*theRows)[i] = new CA <DataType>(m[i]);
    }
}

template <class DataType>
CB<DataType>::CB(const CB<DataType>& a)
{
    deleteRows();
    copy(a);
}

template <class DataType>
void CB<DataType>::operator= (const CB<DataType>& a)
{
    copy(a);
}

template <class DataType>
int CB<DataType>::size() const
{
    return theRows->size();
}

template <class DataType>
CA<DataType>& CB<DataType>::operator[] (int index)
{
    return (*(*theRows)[index]);
}

template <class DataType>
int CB<DataType>::rows()
{ 
    return theRows->size(); 
}

template <class DataType>
int CB<DataType>::columns()
{ 
    return (*this)[0].size(); 
}

uj5u.com熱心網友回復：

問題是目前您已多載為operator[]類template的非常量成員函式CB。這意味著這個成員函式的隱式this引數是型別CB<DataType>*。這意味著我們只能將此成員函式用于非常量物件。

要解決此問題，您需要通過添加 a來使其（多載為）一個const 成員函式const，如下所示，這樣現在隱式this引數將具有型別const CB<DataType>*含義，現在它可以與const物件一起使用。

template <class DataType>
class CB : public CA <CA <DataType> >
{

    virtual CA<DataType>& operator[] (int index) const; //added const here
    //other members here
}
template <class DataType>
CA<DataType>& CB<DataType>::operator[] (int index) const //added const here
{
    return (*(*theRows)[index]);
}
//other code here

程式在修改后編譯，如下所示。

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/433961.html

標籤：C 模板复制构造函数

上一篇：對命名模板引數無效使用不完整型別

下一篇：使用enable_if的部分模板專業化