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

Ilovecc

1. struct HashEntry
   
2.         {
   
3.                 HashedObj element;
   
4.                 EntryType info;
   
5.                 HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY) :element{ e }, info{i}
   
6.                 {
   
7.                 }
   
8.                 HashEntry(HashedObj &&e, EntryType i = EMPTY) :element{ std::move(e) }, info{i}
   
9.                 {
   
10.                 }
    
11.         };

复制代码

这个结构体中的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版本的代码

1. #include <iostream>
   
2. #include <vector>
   
3. 
   
4. using namespace std;
   
5. 
   
6. 
   
7. bool isPrime(int n)
   
8. {
   
9.         if (n == 2 || n == 3)
   
10.                 return true;
    
11. 
    
12.         if (n == 1 || n % 2 == 0)
    
13.                 return false;
    
14. 
    
15.         for (int i = 3; i * i <= n; i += 2)
    
16.                 if (n % i == 0)
    
17.                         return false;
    
18. 
    
19.         return true;
    
20. }
    
21. 
    
22. int nextPrime(int n)
    
23. {
    
24.         if (n % 2 == 0)
    
25.                 ++n;
    
26. 
    
27.         for (; !isPrime(n); n += 2)
    
28.                 ;
    
29. 
    
30.         return n;
    
31. }
    
32. 
    
33. 
    
34. template <typename HashedObj>
    
35. class HashTable
    
36. {
    
37. public:
    
38.         explicit HashTable(int size = 101) :array(nextPrime(size))
    
39.         {
    
40.                 makeEmpty();
    
41.         }
    
42. 
    
43.         void makeEmpty()
    
44.         {
    
45.                 currentSize = 0;
    
46.                 for (auto &entry : array)
    
47.                         entry.info = EMPTY;
    
48.         }
    
49.        
    
50.         bool contains(const HashedObj &x)const
    
51.         {
    
52.                 return isActive(findPos(x));
    
53.         }
    
54. 
    
55.         bool insert(const HashedObj & x)
    
56.         {
    
57.                 int currentPos = findPos(x);
    
58.                 if (isActive(currentPos))
    
59.                         return false;
    
60. 
    
61.                 array[currentPos].element = x;
    
62.                 array[currentPos].info = ACTIVE;
    
63. 
    
64.                 //if (++currentSize >= array.size() / 2)
    
65.                         //rehash();
    
66.                 return true;
    
67.         }
    
68. 
    
69.         bool insert(HashedObj && x)
    
70.         {
    
71.                 HashedObj temp;
    
72.                 swap(temp, x);
    
73.                 return insert(temp);
    
74.         }
    
75. 
    
76.         bool remove(const HashedObj & x)
    
77.         {
    
78.                 int currentPos = findPos(x);
    
79.                 if (!isActive(x))
    
80.                         return false;
    
81. 
    
82.                 array[currentPos].info = DELETED;
    
83.                 --currentSize;
    
84.                 return true;
    
85.         }
    
86. 
    
87.         enum EntryType { ACTIVE, EMPTY, DELETED };
    
88. 
    
89. private:
    
90.         struct HashEntry
    
91.         {
    
92.                 HashedObj element;
    
93.                 EntryType info;
    
94.                 HashEntry(const HashedObj &e = HashedObj{}, EntryType i = EMPTY) :element{ e }, info{i}
    
95.                 {
    
96.                         cout << e << endl;
    
97.                 }
    
98.                 HashEntry(HashedObj &&e, EntryType i = EMPTY) :element{ std::move(e) }, info{i}
    
99.                 {
    
100.                 }
     
101.         };
     
102. 
     
103.         vector<HashEntry> array;
     
104.         int currentSize;
     
105. 
     
106.         bool isActive(int currentPos)const
     
107.         {
     
108.                 return array[currentPos].info == ACTIVE;
     
109.         }
     
110. 
     
111.         int findPos(const HashedObj &x)const
     
112.         {
     
113.                 int offset = 1;
     
114.                 int currentPos = myhash(x);
     
115. 
     
116.                 while (array[currentPos].info != EMPTY && array[currentPos].element != x)
     
117.                 {
     
118.                         currentPos += offset;
     
119.                         offset += 2;
     
120.                         if (currentPos >= (int)array.size())
     
121.                                 currentPos -= array.size();
     
122.                 }
     
123.                 return currentPos;
     
124.         }
     
125.         size_t myhash(const HashedObj &x)const
     
126.         {
     
127.                 static hash<HashedObj> hf;
     
128.                 return hf(x) % array.size();
     
129.         }
     
130.         //void rehash();
     
131. };
     
132. 
     
133. 
     
134. int main()
     
135. {
     
136.         vector<int> a;
     
137.         HashTable<vector<int> *> b;
     
138. 
     
139. }
     

复制代码

Ilovecc

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

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

复制代码

这句话怎么运行的吗

人造人

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

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

好的，大概知道了，谢谢