，但...

Question

我在传递变量（array_size）时遇到问题，我使用命令行从用户那里获取。我需要将此变量传递给HashMap构造函数。在构造函数中，如果我更改＆＃34; array_size＆＃34;到f.e 1000，它可以工作，但我需要它是＆＃34;变量＆＃34; :) 这是我的代码，我真的很感激任何帮助。欢呼声。

#include<iostream>
#include<cstdlib>

using namespace std;
int counter = 1;

class HashEntry
{
    public:
        string key, value;
        HashEntry(string key, string value)
        {
            this->key = key;
            this->value = value;
        }
};

class HashMap
{
    private:
        HashEntry **table;

    public:
        HashMap()
        {
            table = new HashEntry*[array_size];
            for (int i = 0; i < array_size; i++)
            table[i] = NULL;
        }

        void put(string key, string value, int option, int array_size)
        {
            int _key = atoi(key.c_str());
            int hash = _key;
            if(option == 1)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + 10);
                        }
                hash = hash  % array_size;
            }
            else if(option == 2)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + 10 + counter*counter) % array_size;
                        }
            }
            else if(option == 3)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + counter*(_key%(array_size-2)+1));
                    if(hash >= array_size)
                    {
                        hash = 0;
                    }
                }
                hash = hash % array_size;
            }

            if(table[hash] == NULL)
            {
                table[hash] = new HashEntry(key, value);

            }           
            else
                    {
                if (table[hash] != NULL && table[hash]->key == key)
                {
                    table[hash]->value;
                }               
                else
                {                       
                    table[hash] = new HashEntry(key, value);
                }
            }   
        }
};

int main(int argc, char* argv[])
{
    HashMap map;
    string key, value;
    int array_size;

    array_size = atoi(argv[2]);
    int option = atoi(argv[1]);
    int records;
    cin>>records;

    for(int x = 0; x<records; x++)
    {
        cin >> key;
        cin >> value;
        map.put(key, value, option, array_size);
    }
    cout << counter << endl;
    return 0;
}

Answer 1

您的array_size变量位于main函数的范围内。如果您希望此代码正常工作，则可以通过将其放在main函数之外（即在文件的顶部）使array_size具有全局范围。但你真正应该做的是在HashMap类的构造函数中传递array_size。

#include<iostream>
#include<cstdlib>

using namespace std;
int counter = 1;

class HashEntry
{
    public:
        string key, value;
        HashEntry(string key, string value)
        {
            this->key = key;
            this->value = value;
        }
};

class HashMap
{
    private:
        HashEntry **table;
        int array_size;

    public:
        HashMap(int size) :
            array_size(size)
        {
            table = new HashEntry*[array_size];
            for (int i = 0; i < array_size; i++)
            table[i] = NULL;
        }

        void put(string key, string value, int option, int array_size)
        {
            int _key = atoi(key.c_str());
            int hash = _key;
            if(option == 1)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + 10);
                        }
                hash = hash  % array_size;
            }
            else if(option == 2)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + 10 + counter*counter) % array_size;
                        }
            }
            else if(option == 3)
            {
                while (table[hash] != NULL && table[hash]->key != key)
                {
                    counter++;
                    hash = (hash + counter*(_key%(array_size-2)+1));
                    if(hash >= array_size)
                    {
                        hash = 0;
                    }
                }
                hash = hash % array_size;
            }

            if(table[hash] == NULL)
            {
                table[hash] = new HashEntry(key, value);

            }           
            else
                    {
                if (table[hash] != NULL && table[hash]->key == key)
                {
                    table[hash]->value;
                }               
                else
                {                       
                    table[hash] = new HashEntry(key, value);
                }
            }   
        }
};

int main(int argc, char* argv[])
{
    string key, value;
    int array_size;

    array_size = atoi(argv[2]);
    int option = atoi(argv[1]);
    int records;
    cin>>records;

    HashMap map(array_size);

    for(int x = 0; x<records; x++)
    {
        cin >> key;
        cin >> value;
        map.put(key, value, option, array_size);
    }
    cout << counter << endl;
    return 0;
}

Answer 2

叹息。没有人再学习初始化了吗？在知道它应该有多大之前不要创建HashMap对象，并给HashMap一个带有提供所需大小的参数的构造函数。

Answer 3

向array_size构造函数添加HashMap参数，并在知道所需数组的大小后实例化map对象。

#include<iostream>
#include<cstdlib>

using namespace std;
int counter = 1;

class HashEntry {
public:
    string key, value;
    HashEntry (string key, string value)
    {
        this->key = key;
        this->value = value;
    }
};

class HashMap {
private:
    HashEntry **table;

public:
    HashMap (int array_size)    // Add array_size parameter to constructor
    {
        table = new HashEntry*[array_size];
        for (int i = 0; i < array_size; i++)
            table[i] = NULL;
    }

    void put (string key, string value, int option, int array_size)
    {
        int _key = atoi (key.c_str ());
        int hash = _key;
        if (option == 1) {
            while (table[hash] != NULL && table[hash]->key != key) {
                counter++;
                hash = (hash + 10);
            }
            hash = hash  % array_size;
        }
        else if (option == 2) {
            while (table[hash] != NULL && table[hash]->key != key) {
                counter++;
                hash = (hash + 10 + counter*counter) % array_size;
            }
        }
        else if (option == 3) {
            while (table[hash] != NULL && table[hash]->key != key) {
                counter++;
                hash = (hash + counter*(_key % (array_size - 2) + 1));
                if (hash >= array_size) {
                    hash = 0;
                }
            }
            hash = hash % array_size;
        }

        if (table[hash] == NULL) {
            table[hash] = new HashEntry (key, value);

        }
        else {
            if (table[hash] != NULL && table[hash]->key == key) {
                table[hash]->value;
            }
            else {
                table[hash] = new HashEntry (key, value);
            }
        }
    }
};

int main (int argc, char* argv[])
{
    string key, value;
    int array_size;

    array_size = atoi (argv[2]);
    int option = atoi (argv[1]);
    int records;
    cin >> records;

    HashMap map (array_size);   // Declare map using new constructor

    for (int x = 0; x<records; x++) {
        cin >> key;
        cin >> value;
        map.put (key, value, option, array_size);
    }
    cout << counter << endl;
    return 0;
}

Answer 4

函数中定义的变量（包括main）仅在该函数中可见。

您需要将大小从main传递到构造函数

HashMap(int array_size)
{
    table = new HashEntry*[array_size];
    for (int i = 0; i < array_size; i++)
    table[i] = NULL;
}

然后进入main

array_size = atoi(argv[2]);
HashMap map(array_size); // now create the hashmap

，但...

永远不要使用用户输入，不要确定它是好的。如果用户提供＆＃34; fubar＆＃34;而不是一个数字？如果用户指定-10怎么办？还是14.998？ atoi处理这件事并不好。而是使用strtoul或std::stoul。两者都只接受正数，并且很容易测试超出范围的值和无效的输入字符。

将array_size作为成员变量存储在HashMap内也是一个好主意。一个类应该包含并保护它所依赖的所有信息。

HashMap(unsigned int size): array_size(size)
{
    table = new HashEntry*[array_size];
    for (int i = 0; i < array_size; i++)
    table[i] = NULL;
}

和一个新的私有成员变量

unsigned int array_size;

请注意它是unsigned。你不能有一个负大小的阵列，为什么甚至允许这种可能性呢？启用了足够警告的编译器将在提供负值时捕获错误。

并强烈考虑将HashEntry **替换为std::vector。使用当前指针方法，您可以获得许多当前未执行的内存管理。你的程序像筛子一样泄漏记忆。该向量还可以避免您违反the Rule of Three。

将变量（从命令行）传递到类构造函数

4 个答案:

，但...