Comments on: Strong Templates

By: Antoine Morrier

Antoine Morrier — Mon, 05 Mar 2018 22:56:00 +0000

Actually, you could do something like that to improve template reading and others :).

templatestruct type_t{};

template type_t type_c;

template
auto is_pointer(type_t) {return std::is_pointer{};}

// In a function.
auto t = type_c;
if(is_pointer(t)) {

}

You even can declare operator == and do such a thing
static_assert(type_c == type_c);

It is how boost::hana works.

By: Nico Bako

Nico Bako — Tue, 16 Jan 2018 14:36:00 +0000

In reply to Nico Bako. Where Base is defined as :


template&ltclass BaseClass&gt
class Base
{
public:
	template&ltclass DerivedClass&gt
	static bool isBaseOf()
	{
		return std::is_base_of&ltBaseClass, DerivedClass&gt::value;
	}
};

By: Nico Bako

Nico Bako — Tue, 16 Jan 2018 14:33:00 +0000

How about a solution as follows:


Base&ltA&gt::isBaseOf&ltB&gt(); // returns 1
Base&ltB&gt::isBaseOf&ltA&gt(); // returns 0

By: Nico Bako

Nico Bako — Sun, 14 Jan 2018 21:30:00 +0000

Hi guys. I think I have a pretty cool solution to the above mentioned article. In my opinion, one of the major flaws in the function std::is_base_of(Base, Derived) is that the function takes two arguments, and the order of the arguments is crucial. Also, li Let me know what you think.

Also, it appears some text formatting is occurring, and some extra symbols are being added to my code… My code compiles, so if you see something that looks like it won’t compile know that I didn’t type that. Does anyone know how to prevent that?

// Main.cpp #include #include


template

class Base

{

public:

	template

	bool isBaseOf()

	{

		return std::is_base_of::value;

	}
private:

};
class A

{

	// ...

};
class B : public A

{

	// ...

};
int main()

{

	Base baseA;

	std::cout << "Is A base of B : " << baseA.isBaseOf() << std::endl;

	// prints 1

	Base baseB;

	std::cout << "Is B base of A : " << baseB.isBaseOf() << std::endl;

	// prints 0;

std::cin.get(); return 0; }

By: Björn Fahller

Björn Fahller — Wed, 10 Jan 2018 07:53:00 +0000

In reply to Seph De Busser. This is true. It does, which is a disadvantage. The advantage is that it removes the ambiguity of parameter order.

By: Seph De Busser

Seph De Busser — Tue, 09 Jan 2018 22:46:00 +0000

I like this idea a lot, actually. This might also enable to do checking of the types to get compile-time errors clearer and sooner. A poor man’s concepts implementation, if you will. I’ll have to experiment with this a bit later.

By: Seph De Busser

Seph De Busser — Tue, 09 Jan 2018 22:38:00 +0000

In reply to Björn Fahller. Breaking them up like that requires you to use the template keyword, does it not? ie: type_traits::template has_base. I would see that as a major disadvantage because of the added boilerplate on the usage side.

By: Jonathan Boccara

Jonathan Boccara — Tue, 09 Jan 2018 21:42:00 +0000
In reply to Björn Fahller. Nice. Thanks for sharing this Björn.

By: Björn Fahller

Björn Fahller — Tue, 09 Jan 2018 08:58:00 +0000
I think many binary predicate templates become clearer by breaking them up, as is_base<A>::of<B>. The disadvantage is that now you have to come up with two names, one of which will be extremely generic. One could instead imagine scoping them all into a large type_traits-template: type_traits<A>::has_base<B>,type_traits<A>::is_final, type_traits<A>::is_same_as<B>, etc.