避免通过操作从私有构造函数间接实例化

我正在尝试创建一个类，其对象必须包含其值所代表内容的简短描述("名称"(。因此，唯一的公共构造函数应将字符串作为参数。

但是，对于操作，我需要创建临时(无相关名称(对象来计算要分配给现有对象的值。为此，我实现了一个私有构造函数，不应直接或间接使用它来实例化新对象 - 这些临时对象只能通过 operator= 分配给已经存在的对象，它只复制值而不是名称和值。

问题来自使用"自动"。如果按如下方式声明新变量：

auto newObj = obj + obj;

编译器推导运算符+的返回类型，并将其结果直接分配给newObj。这会导致对象具有不相关的名称，该对象应该无法实例化。

此外，仍然可以从某些函数中推断出已经存在的对象的类型，例如：

auto newObj = obj.makeNewObjWithSameTypeButOtherName("Other name");

遵循演示问题的代码：

#include <iostream>
#include <string>
using namespace std;
template<class T>
class Sample
{
public:
Sample(const string&);
Sample<T> makeNewObj(const string&);
// Invalid constructors
Sample();
Sample(const Sample&);
void operator=(const Sample&);
void operator=(const T&);
Sample<T> operator+(const Sample&) const;
void show(void);
private:
// Private constructor used during operations
Sample(const T&);
T _value;
string _name;

};
template<class T>
Sample<T>::Sample(const string& name)
{
this->_name = name;
this->_value = 0;
}
template<class T>
Sample<T>::Sample(const T&value)
{
this->_name = "Temporary variable";
this->_value = value;
}
template<class T>
Sample<T>
Sample<T>::makeNewObj(const string& name)
{
return Sample<T>(name);
}
template<class T>
void
Sample<T>::operator=(const Sample& si)
{
this->_name = this->_name; // Make explicit: Never change the name
this->_value = si._value;
}
template<class T>
void
Sample<T>::operator=(const T& value)
{
this->_name = this->_name; // Make explicit: Never change the name
this->_value = value;
}
template<class T>
Sample<T>
Sample<T>::operator+(const Sample& si) const
{
// if any of the two values are invalid, throw some error
return Sample<T>( this->_value + si._value );
}
template<class T>
void
Sample<T>::show(void)
{
cout << _name << " = " << _value << endl;
}
int main()
{
Sample<double> a("a"), b("b");
a = 1; // Sample::operator=(const T&)
b = 2.2; // Sample::operator=(const T&)
a.show(); // Output: a = 1
b.show(); // Output: b = 2.2
auto c = a.makeNewObj("c"); // Should be possible
c = a + b; // Sample::operator+(const Sample&) and Sample::operator=(const Sample&)
c.show(); // Output: c = 3.2
//    Sample<double> d; // Compiler error as expected: undefined reference to `Sample::Sample()'
//    auto f = a; // Compiler error as expected: undefined reference to `Sample::Sample(Sample const&)'
// This is what I want to avoid - should result in compiler error
auto g = a+c; // No compiler error: uses the private constructor     Sample::Sample(const T&)
g.show(); // Output: Temporary variable = 4.2  <-- !! Object with irrelevant name
}