C++中std::allocator的使用案例详解

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

#include "allocator.hpp"

#include <iostream>

#include <memory>

#include <string>

#include <vector>

namespaceallocator_ {

// reference: C++ Primer(Fifth Edition) 12.2.2

inttest_allocator_1()

{

std::allocator<std::string> alloc;// 可以分配string的allocator对象

intn{ 5 };

autoconstp = alloc.allocate(n);// 分配n个未初始化的string

auto q = p;// q指向最后构造的元素之后的位置

alloc.construct(q++);// *q为空字符串

alloc.construct(q++, 10,'c');// *q为cccccccccc

alloc.construct(q++,"hi");// *q为hi

std::cout << *p << std::endl;// 正确：使用string的输出运算符

//std::cout << *q << std::endl; // 灾难：q指向未构造的内存

std::cout << p[0] << std::endl;

std::cout << p[1] << std::endl;

std::cout << p[2] << std::endl;

while(q != p) {

alloc.destroy(--q);// 释放我们真正构造的string

}

alloc.deallocate(p, n);

return0;

}

inttest_allocator_2()

{

std::vector<int> vi{ 1, 2, 3, 4, 5 };

// 分配比vi中元素所占用空间大一倍的动态内存

std::allocator<int> alloc;

auto p = alloc.allocate(vi.size() * 2);

// 通过拷贝vi中的元素来构造从p开始的元素

/* 类似拷贝算法，uninitialized_copy接受三个迭代器参数。前两个表示输入序列，第三个表示

这些元素将要拷贝到的目的空间。传递给uninitialized_copy的目的位置迭代器必须指向未构造的

内存。与copy不同，uninitialized_copy在给定目的位置构造元素。

类似copy，uninitialized_copy返回(递增后的)目的位置迭代器。因此，一次uninitialized_copy调用

会返回一个指针，指向最后一个构造的元素之后的位置。

*/

auto q = std::uninitialized_copy(vi.begin(), vi.end(), p);

// 将剩余元素初始化为42

std::uninitialized_fill_n(q, vi.size(), 42);

return0;

}

// reference: http://www.modernescpp.com/index.php/memory-management-with-std-allocator

inttest_allocator_3()

{

std::cout << std::endl;

std::allocator<int> intAlloc;

std::cout <<"intAlloc.max_size(): "<< intAlloc.max_size() << std::endl;

int* intArray = intAlloc.allocate(100);

std::cout <<"intArray[4]: "<< intArray[4] << std::endl;

intArray[4] = 2011;

std::cout <<"intArray[4]: "<< intArray[4] << std::endl;

intAlloc.deallocate(intArray, 100);

std::cout << std::endl;

std::allocator<double> doubleAlloc;

std::cout <<"doubleAlloc.max_size(): "<< doubleAlloc.max_size() << std::endl;

std::cout << std::endl;

std::allocator<std::string> stringAlloc;

std::cout <<"stringAlloc.max_size(): "<< stringAlloc.max_size() << std::endl;

std::string* myString = stringAlloc.allocate(3);

stringAlloc.construct(myString,"Hello");

stringAlloc.construct(myString + 1,"World");

stringAlloc.construct(myString + 2,"!");

std::cout << myString[0] <<" "<< myString[1] <<" "<< myString[2] << std::endl;

stringAlloc.destroy(myString);

stringAlloc.destroy(myString + 1);

stringAlloc.destroy(myString + 2);

stringAlloc.deallocate(myString, 3);

std::cout << std::endl;

return0;

}

//

// reference: http://en.cppreference.com/w/cpp/memory/allocator

inttest_allocator_4()

{

std::allocator<int> a1;// default allocator for ints

int* a = a1.allocate(1);// space for one int

a1.construct(a, 7);// construct the int

std::cout << a[0] <<'\n';

a1.deallocate(a, 1);// deallocate space for one int

// default allocator for strings

std::allocator<std::string> a2;

// same, but obtained by rebinding from the type of a1

decltype(a1)::rebind<std::string>::other a2_1;

// same, but obtained by rebinding from the type of a1 via allocator_traits

std::allocator_traits<decltype(a1)>::rebind_alloc<std::string> a2_2;

std::string* s = a2.allocate(2);// space for 2 strings

a2.construct(s,"foo");

a2.construct(s + 1,"bar");

std::cout << s[0] <<' '<< s[1] <<'\n';

a2.destroy(s);

a2.destroy(s + 1);

a2.deallocate(s, 2);

return0;

}

}// namespace allocator_