std::string password, login;
unsigned short TCPport, YearOfBirth;

login = TCPport; // error

TCPport = YearOfBirth; // ok

template< class ContainType >class UniqueType{
  ContainType v;
public:
  UniqueType( ContainType c ): v( c ){}
  operator ContainType(){ return v; }
  // При необходимости перегружаем еще что-нибудь.
};

UniqueType< std::string > password = "******"; // уникальный тип
UniqueType< std::string > login = "rs4i"; // уникальный тип
password = login; // error

R>std::string password, login;
R>unsigned short TCPport, YearOfBirth;
R>

R>login = TCPport; // error
R>

R>TCPport = YearOfBirth; // ok
R>

R>template< class ContainType >class UniqueType{
R>  ContainType v;
R>public:
R>  UniqueType( ContainType c ): v( c ){}
R>  operator ContainType(){ return v; }
R>  // При необходимости перегружаем еще что-нибудь.
R>};
R>

template< class ContainType , class Tag >class UniqueType //...

struct name_tag;
typedef UniqueType<std::string, name_tag> name_type;

template<class type_>
struct tag { typedef type_ type; };

struct name : tag<std::string> {};

R>UniqueType< std::string > password = "******"; // уникальный тип
R>UniqueType< std::string > login = "rs4i"; // уникальный тип
R>password = login; // error
R>

UniqueType< std::string > email = to_string(password); // Хотя email можно было бы проверить на валидность.

struct name_policy
{
  void operator()(const std::string& name) const
  {
    if(name.empty())
      throw invalid_name(empty);
            
    if(is_reserved_name(name))
      throw invalid_name(reserved);
            
    ///...
};

typedef checked_value<std::string, name_policy> name;

template< class ContainType, class TypeName >class UniqueType{
  ContainType v;
public:
  UniqueType( ContainType c ): v( c ){}
  operator ContainType(){ return v; }
};

#define TypedefUniqueType( ContainType, TypeName )\
struct MACRO__##TypeName{};\
typedef UniqueType< ContainType, MACRO__##TypeName > TypeName

TypedefUniqueType( std::string, PasswordType );
PasswordType password;  // уникальный тип

TypedefUniqueType( std::string, LoginType );
LoginType login;  // уникальный тип

login = password; // error

template<typename ContainType_, typename TagType_>
class UniqueType {
public:
  UniqueType(const ContainType_ &rhs) : val_(rhs){}

  // ...

  ContainType_ val_;
}; // UniqueType<>

typedef UniqueType<std::string, class MyTypeName_> MyType;

MyType myVar("text");

UniqueType<std::string, class Password_> pwd("secret password"); // Объявление типа и инициализация

login = password;

int b = //...
int c = //...
int a = b - c; // ошибка, должно быть 'b + с'

template<class T, int>
class UniqueType{ /**/ };
//...

UniqueType<std::string, 0> login = ...
UniqueType<std::string, 1> pass  = ...
// или так
UniqueType<std::string, __LINE__> login = ...

template<class Tag>class UniqueType {
 typename Tag::type v;
 //...
}
//...
UniqueType<name> n = ...;

17.4.3.6 Other functions
2 In particular, the effects are undefined in the following cases:
— if an incomplete type (3.9) is used as a template argument when instantiating a template component.

AF>и совсем забыл, что глава 17 называется "Library introduction"

14.3.1/2
A local type, a type with no linkage, an unnamed type or a type compounded from any of these types shall
not be used as a template-argument for a template type-parameter

UniqueType<std::string, class Password_1> pwd("secret password"); // ok

void f()
{
  UniqueType<std::string, class Password_2> pwd("secret password"); //error
}

template <class T> class X { };
template <class T> void f(T t) { }
struct { } unnamed_obj;

void f() {
  struct A { };
  enum { e1 };
  typedef struct { } B;
  B b;
  X<A> x1; // OK
  X<A*> x2; // OK
  X<B> x3; // OK
  f(e1); // OK
  f(unnamed_obj); // OK
  f(b); // OK
}

template<class> struct X{};

int main()
{
  X<void> v;
}

AF>[...skip...]
ГВ>>UniqueType<std::string, class Password_> pwd("secret password"); // Объявление типа и инициализация
ГВ>>

AF>Кажется, инстанцирование неполными типами приводит к ub... Или тут какое-то хитрое исключение?

template<typename IncompleteOne_> class X { ... };

namespace ns1 {
X<class Z_> xz;
}

// тег для логина
struct Login
{
    typedef std::string Type;
};
// тег для пароля
struct Password
{
    typedef std::string Type;
};

template<typename T>
class UniqueType
{
public:
     typedef typename T::Type Type;

     explicit UniqueType(const T &value) : value(value) {}
...
private:
     Type value; 
};

...
UniqueType<Login> login("User");
UniqueType<Password> password("***");