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
|
Usually a tt(shared_ptr) is initialized at definition time
with a pointer to a newly allocated object. Here is an example:
verb(
std::shared_ptr<string> sptr(new std::string("hello world"))
)
In such statements em(two) memory allocation calls are used: one for the
allocation of the tt(std::string) and one used interally by
tt(std::shared_ptr)'s constructor itself.
The two allocations can be combined into one single allocation (which is
also slightly more efficient than explicitly calling tt(shared_ptr)'s
constructor) using the ti(make_shared) template. The function template
tt(std::make_shared) has the following prototype:
verb(
template<typename Type, typename ...Args>
std::shared_ptr<Type> std::make_shared(Args ...args);
)
Before using tt(make_shared) the tthi(memory) header file must be included.
This function template allocates an object of type tt(Type), passing
tt(args) to its constructor (using em(perfect forwarding), see section
ref(PERFECT)), and returns a tt(shared_ptr) initialized with the address of
the newly allocated tt(Type) object.
Here is how the above tt(sptr) object can be initialized
using tt(std::make_shared). Notice the use of tt(auto) which frees us from
having to specify tt(sptr)'s type explicitly:
verb(
auto sptr(std::make_shared<std::string>("hello world"));
)
After this initialization tt(std::shared_ptr<std::string> sptr) has been
defined and initialized. It could be used as follows:
verb(
std::cout << *sptr << '\n';
)
In addition to tt(make_shared) the function
hi(make_unique)tt(std::make_unique) can be used. It can be used
tt(make_shared) but returns a tt(std::unique_ptr) rather than a
tt(shared_ptr).
|
