Q:

How to tell which class owns a pointer

I was watching a vid about smart pointers (vid link below), which identifies the following problem with traditional C++ pointers:
You can't tell who owns the pointer
Hebert goes on to give the following example: Class A has a pointer to a float, class B has a pointer to that same float.  Which of the two owns the pointer?  Well, you can't tell... it's not clear... we don't know whose job it is do delete the pointer.. .bad.. convoluted.. hard to debug. 
What the heck is he talking about?  How are we not able tell which class owns the pointer?  If the pointer is created as part of class A or B's instance, then would it not simply be A->myPointer, and B->myPointer, respectively? 
Thx :^) Keith
https://www.youtube.com/watch?v=Jc9n9BcYSj4
At about 1:00
EDIT
#include <iostream>
class A {
public: float * f_ptr;
};
class B {
public: float * f_ptr;
};
int main() {
    float f=2.71;
    A* a = new(A);
    B* b = new(B);
    a->f_ptr = &f;
    b->f_ptr = &f;
    std::cout << "a->f_ptr: " << *a->f_ptr << std::endl;
    std::cout << "b->f_ptr: " << *b->f_ptr << std::endl;
    delete a;
    delete b;
    std::cout << std::endl;
}

/************
OUTPUT

a->f_ptr: 2.71
b->f_ptr: 2.71

*/

EDIT 2
The following post explains this phenomenon very well:
http://ericlavesson.blogspot.com/2013/03/c-ownership-semantics.html

A:

When he says that some class "owns the pointer", that means that this class is responsible for cleaning up the mess the pointer does.  You can have two different classes A and B that use a pointer that points to the same object.  Unless you are the designer of these classes, you can't tell which one should delete the object in the end and do the cleaning after it, e.g. unlocking some resources.  You can't figure that out or set it by using some built-in language semantics - you have to be told about it, e.g. via documentation.  If the design is bad, you may end up with two classes trying to clean after the same object twice or not cleaning up after the object at all. 
Technically it's about who owns the memory that the pointer points to, not about the pointers themselves, but most people refer to the problem I have described above while talking about owning a pointer.