Multi-level CRTP and Initialization

#include <iostream>
#include <string>
#include <memory>
struct Val
{
std::string str;
void append(const std::string n)
{
str += n;
}
Val() : str("x")
{
}
};
template<typename T>
class base
{
public:
base(int n)
{
std::cout << "Base " << n << "\n";
// triggers error if not ptr
print();
}
void print()
{
static_cast<T*>(this)->impl_print();
}
~base()
{
std::cout << "DB\n";
}
};
template<typename T, typename V>
class implA : public base<implA<T, V>>
{
friend class base<implA<T, V>>;
public:
implA(int n) : base<implA<T, V>>(n)
{
std::cout << "implA " << n << "\n";
for (int i = 0; i < n; i++)
{
implVal->append(std::to_string(n));
}
}
~implA()
{
std::cout << "iA\n";
}
protected:
std::shared_ptr<V> implVal =  NULL;
void impl_print()
{
if (implVal == NULL)
{
implVal = std::make_shared<V>();
}
static_cast<T*>(this)->impl_print(*implVal);
}
};
class classX : public implA<classX, Val>
{
friend class implA<classX, Val>;
public:
classX(int n) : implA<classX, Val>(n)
{
std::cout << "classX " << n << "\n";
}
protected:
void impl_print(Val in)
{
std::cout<<"p"<< in.str << "\n";
}
};
int main()
{
classX x(2);
x.print();
return 0;
}

Trying to do some multi-level inheritance where the the arguments to a constructor modify the members of the mid-level during construction. Ran into the problem that implVal hasn't been allocated when base triggers its print, so calls to use its value will cause a runtime error.

Tried to fix that by changing implVal to a pointer and allocating it manually when needed. That allows the internal call to print to work, but when the body of implClass constructor resolves, implClass is null again, as if memory was never allocated. This causes a null ptr error when trying to modify the value. What is going on here?

base(int n)
{
std::cout << "Base " << n << "\n";
// triggers error if not ptr
print();
}
void print()
{
static_cast<T*>(this)->impl_print();
}

this pattern is fundamentally not safe.

Your children are not constructed until after your constructor returns, and there is no simple way to run code after your children are constructed in C++.

Modifying members of a non-constructed object (or a non-constructed part of an object) is UB. Don't do it. Even if it works, it isn't guaranteed to work the next time your compiler detects a change in the moon phase (or other seemingly unrelated reasons).

The best you can do is have a post-construct pattern. The most-derived class is responsible to call a post_construct method.

I am unaware of a way to cleanly enforce that your derived T will call post-construct.

Sticking with the code as posted, you're breaking the rules here. When the base constructor runs, implA doesn't exist yet. Calling any methods of implA is therefore UB, hence your crash.

CRTP offers no protection to stop you from doing this (whereas regular classes with virtual functions do, for very good reasons). The solution I use is to have a factory function that constructs the object before calling methods on it.