Is my assumption, that in following example, memory referenced by b will be deallocated once instance of A goes out of scope at end of func(), correct?
class A{
public:
A() {
b = std::shared_ptr<char>(new char[100] { 0 } );
}
char* b;
}
void func {
A a;
}
No, not correct. b is of type char * and you assign to it a shared_ptr<char>. You should get a compilation error.
Furthermore, the constructor is private, another compilation error.
And how do you access b in func()? It is private in A.
Obviously your exercise is incomplete... so I just go from what you provided.
Also I suggest to use unique_ptr in case you can say it is a unique ownership (which it appears to be in my opinion).
This compiles:
#include <memory>
#include <iostream>
class A {
public:
A() {
std::cout << "A created with unique pointer" << std::endl;
b = std::unique_ptr<char>(new char[100] {
0
});
}
~A() {
std::cout << "A destroyed" << std::endl;
}
private:
std::unique_ptr<char> b;
};
void func() {
A a;
}
int main() {
std::cout << "Call func()" << std::endl;
func();
std::cout << "func() called" << std::endl;
return 0;
}
And at the end of func() A is destroyed and with it the unique_ptr.
However, ask yourself if you really need to use pointer? In your case an automatic variable should be just fine; it does the same (i.e. being destroyed when func() exits.
You're assigning to a char* member, so I'm pretty sure the shared_ptr is cleaned up as soon as the assignment completes (because it wasn't stored to another shared_ptr that would maintain the reference count).
If you want to use shared_ptrs, you have to use them consistently; a raw pointer class member can't manage anything for you. The pointer is still initialized to where the memory was allocated, but it's not allocated anymore; accessing it even a line later in the constructor would be undefined behavior/a use-after-free bug.
In any event, not safe because default shared_ptr uses delete, not delete[]. Is there some reason a std::shared_ptr<std::array<char, 100>> couldn't be used?
b doesn't increases shared_ptr's ref count? And why does std::shared_ptr<std::array<char, 100>> work correctly?
shared_ptrwith an array in that fashion is correct. Maybe it is, I'm not sure.shared_ptr<T[]>has been proposed for C++17. I thought I saw somewhere that it was accepted, but I could be wrong.