e.g. using smart pointers.. There are several people who though that would not be possible.. and exceptions ofc

Exceptions do not leak if you use RAII

Exceptions can lead to leakage

e.g. using smart pointers.. There are several people who though that would not be possible.. and exceptions ofc

Exceptions can lead to leakage

Explain me how you can leak memory due to exceptions if you properly do RAII

that was one reason why std::make_unique has been added to C++14

what does make_unique do?

what does make_unique do?

C can literally leak anything

creates a unique pointer without leaking memory

where is the difference between unique_ptr and shared_ptr?

both just wrap c-style pointers

what does make_unique do?

Use Google u piece of shit. [That's how nice it sounds] unique_ptr<maxi> MX = std::make_unique<maxi>(args_go_here);

You want to leak something tragic? File descriptors

Also, leaks of memory space

Use Google u piece of shit. sorry

NP. Just telling that sometimes u might wanna overlook some people and don't trash them yet

you cannot copy a unique_ptr, it uses no reference counting. Once a unique_ptr goes out of scope it ideallocates the memory. a shared_ptr uses ref counting and the last one will release the memory

sorryhhhhhh ;_;

you cannot copy a unique_ptr, it uses no reference counting. Once a unique_ptr goes out of scope it ideallocates the memory. a shared_ptr uses ref counting and the last one will release the memory

how does ref counting work?

sorryhhhhhh ;_;

It is in the name

how does ref counting work?

Your butt pls . Spanking spree

yea but how does he count the references?

on each copy you increase the count by one. In the destructor you decrease it. Once you reach zero references you know the object is no longer being reachable and you can delete it

oh that makes sense. but the counter is a global variable?

there is a global state that each shared_ptr has a pointer to. But not totally global

In general, a pointer to a std::atomic_int

Construct a unique_ptr whose memory is allocated from a std::allocator directly

are you sure about the std::allocator part? http://eel.is/c++draft/unique.ptr.create#2 "Unlike std::make_shared (which has std::allocate_shared), std::make_unique does not have an allocator-aware counterpart"

New uses the standard allocator

are you sure about the std::allocator part? http://eel.is/c++draft/unique.ptr.create#2 "Unlike std::make_shared (which has std::allocate_shared), std::make_unique does not have an allocator-aware counterpart"

https://en.cppreference.com/w/cpp/memory/allocator/allocate allocator uses new

A = B implies B = A

that's no equality

A = B implies B = A

New uses the standard allocator

but this is not right, since :: operator new is called by allocate ant not the other way around

Allocate is mostly solely composed of call to new

@linuxer4fun I canot reproduce this. Neither Clang, G++, nor MSVC compiles it. imho Clang has the best error diagnostic <source>:13:16: error: variable 'lambda' declared with deduced type 'auto' cannot appear in its own initializer See: https://godbolt.org/z/7B30bp

interesting. It runs on my local machine and there https://www.onlinegdb.com/online_c++_compiler

Its the link in my message above

https://onlinegdb.com/ryxxhKNbYX oh lol my bad

I assume this is a bug right?

is there a resource that specify how type deduction should work?

Hello..what does this group function ??