SmartPointer | simple Smart Pointer class , including strong_ptr | Transpiler library

You have needlessly many template parameters. You could follow the way it is done in a corresponding test. Define your function, set it via filter->SetFunctor() and call Update().

C++ is Unique_ptr pertinent for vectors of vectors

That's for you to decide, but only rapidly looking at the code without other knowledge of the infrastructure, I would say that this is a heavy, terrible code smell. I would simply use the vector as is. It's lighter, safer, simpler, and faster.

A pointer to a STL containe is usually a strong indicator of code smell, and a pointer to a STL container that contains pointer to STL containers has even a stronger code smell. This would simply not pass review and I would urge to simplify.

Owning pointers to STL containers should practically not exist in a code, unless there is some class that encapsulate very special memory management through container pointers, but they should not escape that class. And even then, you can manage memory and reuse with simple container values.

You should give value semantics a try! It helps local thinking and usually make code simpler.

Now for the non opinion based part of the question.

Let's drop the superfluous unique pointers in your code so it's easier to explain:

First of all, to understand the difference, and since you are new to C++, I would recommend reading on the following topics:

• Dynamic memory allocation (new/delete)
• Memory leaks
• Casting
• Templates

With this approach, you are getting a raw pointer (as opposed to a smart pointer) to a widget defined from the ui file. Example:

You appear to be writing something similar to shared_ptr.

For a shared_ptr-like smart pointer, each smart pointer has both a pointer-to-object and a pointer-to-control-block.

When you are constructed with a pointer-to-object, you are responsible to create the control block.

In your case, your control block name is ReferenceCount.

So add a new ReferenceCount to that constructor. Probably start it off with a count of 1.

I suppose your problem (with a single constructor) is caused from "vexing parse" (here a description of the "most vexing parse problem", a more spectacular version of the problem).

I mean... if you write

Something along these lines, perhaps:

You might use variadic template:

The operator-> function should return a pointer. And it should be a pointer to the wrapped object:

The problem is that your TObjectList holds raw TTestObj object pointers, not the IShared interfaces that Shared.Make() returns.

In var lTestList := Shared.Make(TTestList.Create)();, you are creating an IShared (a reference to function: TTestList) that wraps a TTestList object you are creating. You are invoking () on the IShared, which calls the function to return the raw TTestList object pointer. Which is OK in this example, because the IShared will be held in a hidden variable for the lifetime of Test_SmartPointer(), thus its refcount is 1, keeping the TTestList alive.

In var lTestObj := Shared.Make(TTestObj.Create)(); you are doing the same thing, this time for an IShared returning an TTestObj object pointer. However, when lTestObj goes out of scope at the end of each loop iteration, the refcount of the IShared is decremented. Since there are no further references to that interface, its refcount falls to 0, destroying the object behind the IShared, which in turn destroys its associated TTestObj object, leaving the TObjectList with a dangling TTestObj pointer (but you don't experience any crashes with that, since you are not accessing the stored TTestObj objects in any way, not even in the TObjectList destructor due to OwnsObjects=false).

You need to change TTestList to hold IShared elements instead of TTestObj elements (in that case, you should use TList instead of TObjectList), and get rid of the () invocations on the IShared interfaces when calling Shared.Make():