[已解决]c++模板的传参的一个问题

Ilovecc

struct HashEntry
        {
                HashedObj element;
                EntryType info;
                HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY) :element{ e }, info{i}
                {
                }
                HashEntry(HashedObj &&e, EntryType i = EMPTY) :element{ std::move(e) }, info{i}
                {
                }
        };

这个结构体中的HashedObj类型是一个模板，当它为一个指针类型时HashedObj{}这句话怎么完成初始化的呢？

当HashedObj为vector<int> *类型时，HashedObj{}应该类似于"vector<int> *{}"?,这样也不能构成无名对象啊，还是编译器的优化？

最佳答案

月排行榜 / 总排行榜

人造人

2018-12-24 12:58:09

Ilovecc 发表于 2018-12-24 09:47
如果HashedObj 为一个vector的类型的话，vector{}（或HashedObj {}）就是一个无名对象，HashedObj为指针 ...

跳转到最佳答案楼层

人造人

什么？
把例子举完整

Ilovecc

人造人 发表于 2018-12-23 16:53
什么？
把例子举完整

比如HashedObj 为一个vector<int> *的类型，HashedObj{}这一句怎么完成对初始化的呢

人造人

Ilovecc 发表于 2018-12-23 16:55
比如HashedObj 为一个vector *的类型，HashedObj{}这一句怎么完成对初始化的呢

要代码，完整的，可以运行的实例

Ilovecc

人造人 发表于 2018-12-23 17:33
要代码，完整的，可以运行的实例

这是c++11版本的代码

#include <iostream>
#include <vector>

using namespace std;


bool isPrime(int n)
{
        if (n == 2 || n == 3)
                return true;

        if (n == 1 || n % 2 == 0)
                return false;

        for (int i = 3; i * i <= n; i += 2)
                if (n % i == 0)
                        return false;

        return true;
}

int nextPrime(int n)
{
        if (n % 2 == 0)
                ++n;

        for (; !isPrime(n); n += 2)
                ;

        return n;
}


template <typename HashedObj>
class HashTable
{
public:
        explicit HashTable(int size = 101) :array(nextPrime(size))
        {
                makeEmpty();
        }

        void makeEmpty()
        {
                currentSize = 0;
                for (auto &entry : array)
                        entry.info = EMPTY;
        }
        
        bool contains(const HashedObj &x)const
        {
                return isActive(findPos(x));
        }

        bool insert(const HashedObj & x)
        {
                int currentPos = findPos(x);
                if (isActive(currentPos))
                        return false;

                array[currentPos].element = x;
                array[currentPos].info = ACTIVE;

                //if (++currentSize >= array.size() / 2)
                        //rehash();
                return true;
        }

        bool insert(HashedObj && x)
        {
                HashedObj temp;
                swap(temp, x);
                return insert(temp);
        }

        bool remove(const HashedObj & x)
        {
                int currentPos = findPos(x);
                if (!isActive(x))
                        return false;

                array[currentPos].info = DELETED;
                --currentSize;
                return true;
        }

        enum EntryType { ACTIVE, EMPTY, DELETED };

private:
        struct HashEntry
        {
                HashedObj element;
                EntryType info;
                HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY) :element{ e }, info{i}
                {
                        cout << e << endl;
                }
                HashEntry(HashedObj &&e, EntryType i = EMPTY) :element{ std::move(e) }, info{i}
                {
                }
        };

        vector<HashEntry> array;
        int currentSize;

        bool isActive(int currentPos)const
        {
                return array[currentPos].info == ACTIVE;
        }

        int findPos(const HashedObj &x)const
        {
                int offset = 1;
                int currentPos = myhash(x);

                while (array[currentPos].info != EMPTY && array[currentPos].element != x)
                {
                        currentPos += offset;
                        offset += 2;
                        if (currentPos >= (int)array.size())
                                currentPos -= array.size();
                }
                return currentPos;
        }
        size_t myhash(const HashedObj &x)const
        {
                static hash<HashedObj> hf;
                return hf(x) % array.size();
        }
        //void rehash();
};


int main()
{
        vector<int> a;
        HashTable<vector<int> *> b;

}

Ilovecc

有大佬能解释一下当HashedObj 为vector<int> *之类的指针类型时，

HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY) :element{ e }, info{i}
{}

这句话怎么运行的吗

人造人

不知道你怎么样，我反正是看明白了

HashTable<vector<int> *> b;

template <typename HashedObj>

HashedObj 就是 vector<int> *

HashedObj 是一个指针，这个指针指向vector，vector中存储的是int

vector<HashEntry> array;
array是一个vector，vector中存储的是 HashEntry

explicit HashTable(int size = 101):array(nextPrime(size))
创建array并且创建size个HashEntry对象存储到array


HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY):element{e}, info{i}

HashedObj &e
HashedObj 是一个指针，这个指针指向vector，vector中存储的是int
e是一个引用，引用了一个HashedObj
e是一个引用，引用了一个 指针，这个指针指向vector，vector中存储的是int

人造人

学过汇编语言吗？有汇编语言基础就好说了

人造人

Ilovecc

人造人 发表于 2018-12-23 23:00

汇编已经看不懂了。。。，不过HashedObj 是指针，struct HashEntry的构造函数中的HashedObj{}是不是可以替换成vector<int>*{},我主要是这里的默认值看不懂，vector<int>*{}这句怎么给e赋值为nullptr的呢？

Ilovecc

人造人 发表于 2018-12-23 23:00

如果HashedObj 为一个vector<int>的类型的话，vector<int>{}（或HashedObj {}）就是一个无名对象，HashedObj为指针类型时，是怎么理解呢

人造人

Ilovecc 发表于 2018-12-24 09:47
如果HashedObj 为一个vector的类型的话，vector{}（或HashedObj {}）就是一个无名对象，HashedObj为指针 ...

人造人

Ilovecc

人造人 发表于 2018-12-24 12:59

好的，大概知道了，谢谢