C++ 访问私有类变量时出现分段错误 \define TABLE\u SIZE 100489//必须是2的幂 类型定义映射类型； typedef对_型； 类哈希表 { 公共职能 哈希表（）； ~HashTable（）； int查找（字符串）； 布尔插入（字符串，整数）； 私人： 整数散列（常量字符*）； 向量v； }; //哈希表构造函数 HashTable:：HashTable（） { 向量v；//初始化映射的向量 v、 保留（表大小）；//保留表大小 MAP_型m； 对于（int i=0；iv.reserve（表大小）；//保留表大小 MAP_型m； 对于（int i=0；iv.向后推（m）； }

您从来没有在私有成员变量vector

v

中插入任何内容。您在哈希表构造函数中创建了一个作为本地堆栈变量的向量，您也将其命名为

v

。然后，您继续将项插入到该临时向量中，一旦您离开构造函数，该向量就超出了范围。因此当然，稍后，在

哈希表：：find

函数中，类成员变量

v

为空

您的构造函数应该类似于：

#define TABLE_SIZE 100489 // must be a power of 2
typedef map<string,int> MAP_TYPE;
typedef pair<string, int> PAIR_TYPE;

class HashTable
{
public:                                     //public functions
    HashTable();
    ~HashTable();
    int find(string);
    bool insert(string, int);
private:
    int hash( const char* );
    vector< MAP_TYPE > v;
};

//HashTable constructor
HashTable::HashTable()
{
    vector< MAP_TYPE > v;               //initialize vector of maps
    v.reserve(TABLE_SIZE);                  //reserve table size
    MAP_TYPE m;
    for (int i = 0; i < TABLE_SIZE; ++i)    //fill vector with empty maps
    v.push_back(m);
    cout << v.size();
}

int HashTable::find(string key)
{
    cout << "in find" << '\n';
    //String to const char* for hash function
    const char *c = key.c_str();
    //find bucket where key is located
    int hashValue = HashTable::hash(c);
    cout << hashValue << '\n';
    string s = key;
    cout << v.size(); //Prints 0 but should be TABLE_SIZE
    //look for key in map in bucket
    MAP_TYPE::const_iterator iter = v[hashValue].find(s);
    if ( iter != v[hashValue].end()) //check if find exists
        return iter->second; //return value of key
    else
        return -1; //arbitrary value signifying failure to find key
}

int main()
{
    HashTable my_hash;
    string s = "hi";
    int z = my_hash.find(s);
    cout << z; //should return -1
    return 0;
}

//哈希表构造函数
HashTable:：HashTable（）
{
此->v.reserve（表大小）；//保留表大小
MAP_型m；
对于（int i=0；iv.向后推（m）；
}

在上面，我使用

this

关键字强调我正在访问私有成员变量

v

，但您不需要它。（不过，通常最好为私有成员变量采用命名约定，例如添加

后缀或

m

前缀或其他东西。）

---

初始化向量的更好方法是，按照答案中的建议，简单地使用向量的填充构造函数。

您从来没有在私有成员变量vector

v

中插入任何内容。您可以在哈希表构造函数中创建一个向量作为局部堆栈变量，也可以将其命名为

v

。您可以然后继续将项插入到临时向量中，一旦离开构造函数，临时向量就超出范围。因此，当然，稍后在

HashTable:：find

函数中，类成员变量

v

为空

您的构造函数应该类似于：

#define TABLE_SIZE 100489 // must be a power of 2
typedef map<string,int> MAP_TYPE;
typedef pair<string, int> PAIR_TYPE;

class HashTable
{
public:                                     //public functions
    HashTable();
    ~HashTable();
    int find(string);
    bool insert(string, int);
private:
    int hash( const char* );
    vector< MAP_TYPE > v;
};

//HashTable constructor
HashTable::HashTable()
{
    vector< MAP_TYPE > v;               //initialize vector of maps
    v.reserve(TABLE_SIZE);                  //reserve table size
    MAP_TYPE m;
    for (int i = 0; i < TABLE_SIZE; ++i)    //fill vector with empty maps
    v.push_back(m);
    cout << v.size();
}

int HashTable::find(string key)
{
    cout << "in find" << '\n';
    //String to const char* for hash function
    const char *c = key.c_str();
    //find bucket where key is located
    int hashValue = HashTable::hash(c);
    cout << hashValue << '\n';
    string s = key;
    cout << v.size(); //Prints 0 but should be TABLE_SIZE
    //look for key in map in bucket
    MAP_TYPE::const_iterator iter = v[hashValue].find(s);
    if ( iter != v[hashValue].end()) //check if find exists
        return iter->second; //return value of key
    else
        return -1; //arbitrary value signifying failure to find key
}

int main()
{
    HashTable my_hash;
    string s = "hi";
    int z = my_hash.find(s);
    cout << z; //should return -1
    return 0;
}

//哈希表构造函数
HashTable:：HashTable（）
{
此->v.reserve（表大小）；//保留表大小
MAP_型m；
对于（int i=0；iv.向后推（m）；
}

在上面，我使用

this

关键字强调我正在访问私有成员变量

v

，但您不需要它。（不过，通常最好为私有成员变量采用命名约定，例如添加

后缀或

m

前缀或其他东西。）

---

初始化向量的更好的方法是简单地使用向量的填充构造函数，正如答案中所建议的那样。

函数中有一个名为v的局部变量以及一个私有类成员v

尝试：

---

this->v

函数中有一个名为v的局部变量以及一个私有类成员v

尝试：

---

<代码>：C++类变量在初始化列表中最好初始化：

>/P>>P>：

//HashTable constructor
HashTable::HashTable()
{
    this->v.reserve(TABLE_SIZE);                  //reserve table size
    MAP_TYPE m;
    for (int i = 0; i < TABLE_SIZE; ++i)    //fill vector with empty maps
        this->v.push_back(m);
}

std:：vector

有一个采用大小和默认值的构造函数，因此您可以直接调用它。事实上，由于要使用的默认值实际上是使用默认构造函数创建的映射，您实际上可以编写以下内容，因为在这种情况下可以忽略第二个参数：

HashTable::HashTable() : v(TABLE_SIZE, MAP_TYPE()) // **here**
{}

---

在初始化列表中，C++类变量最好初始化：

//HashTable constructor
HashTable::HashTable()
{
    this->v.reserve(TABLE_SIZE);                  //reserve table size
    MAP_TYPE m;
    for (int i = 0; i < TABLE_SIZE; ++i)    //fill vector with empty maps
        this->v.push_back(m);
}

std:：vector

有一个采用大小和默认值的构造函数，因此您可以直接调用它。事实上，由于要使用的默认值实际上是使用默认构造函数创建的映射，您实际上可以编写以下内容，因为在这种情况下可以忽略第二个参数：

HashTable::HashTable() : v(TABLE_SIZE, MAP_TYPE()) // **here**
{}

---

100489！=的功率2@Mysticial这就是为什么注释会产生错误的断言语句。eeep！是的，但这不重要……哈希值在向量的大小之内。v.size（）在find中，任何一种方式都不应该给我0？hash的定义在哪里？100489！=的幂2@Mysticial这就是为什么注释会产生错误的断言语句。eeep！是的，但这不重要……哈希值在向量的大小之内。v.size（）在find中，任何一种方式都不应该给我0？hash的定义在哪里？