为什么我不能使C ++中的对象具有作为其他对象的数据成员？

Question

有一天我很无聊，所以我做了这个图书馆：

template <class X, class Y> class HASH
{
public:
HASH(X element, Y key)
{
    elements=new X[0];
    keys=new Y[0];
    keys[0]=key;
    elements[0]=element;
    num_elements=0;
};
~HASH ()
{
    delete[] elements;
    delete[] keys;
};
void Add(X element, Y key)
{
    for (int x=0; x<=num_elements; x++)
    {
        if (keys[x]==key)
        {
            throw(key);
        }
    }
    //make copy variables
    X *copy_elements=new X[num_elements];
    Y *copy_keys=new Y[num_elements];
    //copy all the elements
    for (int x=0; x<=num_elements; x++)
    {
        copy_elements[x]=elements[x];
        copy_keys[x]=keys[x];
    }
    //delete the originals
    delete[] elements;
    delete[] keys;
    //resize the originals
    elements=new X[num_elements+1];
    keys=new Y[num_elements+1];
    //copy everything back to the originals
    for (int x=0; x<=num_elements; x++)
    {
        elements[x]=copy_elements[x];
        keys[x]=copy_keys[x];
    }
    //delete the copies
    delete[] copy_keys;
    delete[] copy_elements;
    //increment num_elements
    num_elements++;
    //add the new elements
    elements[num_elements]=element;
    keys[num_elements]=key;
};
X operator [] (Y key)
{
    int num=0;
    for (int x=0; x<=num_elements; x++)
    {
        if (keys[x]==key)
        {
            num=x;
            break;
        }
    }
    return elements[num];
};
Y KeyNum(int x)
{
    return keys[x];
};
int NumElements()
{
    return num_elements;
};
private:
int num_elements;
X *elements;
Y *keys;
};

然后我对其进行了测试，并且效果良好。 因此，现在我试图创建一个实验，其源代码是这样的：

#include <hash.cpp>
#include <iostream>
using namespace std;

class OBJECT 
{
    public:
        OBJECT(string name, int number)
        {
            int_properties=new HASH <string, int>;
        };
        ~OBJECT()
        {
            delete int_properties;
        };
        HASH <string, int> *int_properties;
};

int main()
{
    OBJECT a("name", 5);
    return 0;
}

它返回错误：

brain.cpp: In constructor ‘OBJECT::OBJECT(std::string, int)’:
brain.cpp:10: error: no matching function for call to ‘HASH<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>::HASH()’
/usr/include/hash.cpp:4: note: candidates are: HASH<X, Y>::HASH(X, Y) [with X = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, Y = int]
/usr/include/hash.cpp:2: note:                 HASH<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>::HASH(const HASH<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>&)

我已经进行了很多测试，无论我做什么，似乎都无法初始化一个对象，该对象是另一个对象的数据成员。 我只是不明白为什么。

Answer 1

您声明一个构造函数，该构造函数采用HASH<X, Y> ：

HASH(X element, Y key)
{
    elements=new X[0];
    keys=new Y[0];
    keys[0]=key;
    elements[0]=element;
    num_elements=0;
};

然后尝试在OBJECT::OBJECT分配HASH<string, int> ：

OBJECT(string name, int number)  
{  
    int_properties=new HASH <string, int>;  
};  

您只需要将name和number传递给HASH<string, int>的构造函数：

    int_properties=new HASH <string, int>(name, number);

Answer 2

brain.cpp: In constructor ‘OBJECT::OBJECT(std::string, int)’: brain.cpp:10: error: no matching function for call to ‘HASH, std::allocator >, int>::HASH()’

这是正确的。 您尚未为HASH类定义默认的构造函数。

Answer 3

在C ++中，对象当然可以是其他对象的数据成员。 否则，您将只能拥有由原始类型组成的类，那将几乎没有用处。

这里的问题是您的class HASH没有默认的构造函数。

如果根本不指定构造函数，则编译器将为您创建一个默认构造函数。 但是，一旦定义了非默认构造函数，编译器将不再提供默认构造函数。

因此，要么必须向创建的HASH对象传递元素和键，要么必须为class HASH提供默认的构造函数，这大概会创建一个空的哈希表。

Answer 4

没有默认的构造函数：

int_properties=new HASH <string, int>; // No constructor that takes zero arguments to HASH

Answer 5

您的HASH类没有默认的构造函数。 您的OBJECT构造函数应为

OBJECT(string name, int number)
{
   int_properties=new HASH <string, int>(name, number);
};

Answer 6

int_properties = new HASH <string, int>;

该行尝试调用class HASH<string, int>的默认构造函数。 也就是说，它尝试使用零个对象调用构造函数。 但是没有这样的构造函数。 您定义的构造函数是HASH<string, int>::HASH(string element, int key) ，它需要两个参数。

模板参数显示在<> 。 函数参数出现在() 。 不要混淆两者。

您可以通过添加一些函数参数定义的构造函数来解决此问题：

int_properties = new HASH<string, int> (name, number);

或通过修改或重载构造函数，使其可以接受零参数并成为默认构造函数。

template <class X, class Y> class HASH {
public:
  HASH();
  //...
};

template <class X, class Y> HASH<X,Y>::HASH() { /*...*/ }

Answer 7

HASH是模板类，您不能直接实例化它。