Bind both lvalues and rvalues to variadic class template parameter

Question

I have a class template that take a variadic number of template arguments. The class has some functions that take arguments corresponding to the class's template parameters. I would like these functions to bind to both lvalues and rvalues. How can I achieve this?

template<class ...C>
class Graph {
public:
    Graph(C &...Context); // <- Only lvalues
    Graph(C &&...Context); // <- Only rvalues
    Graph(auto &&...Context); // <- Both lvalues and rvalues, but does not enforce that the types correspond to ...C
};

It doesn't seem to be possible to create a concept inside the class. Can I create a concept outside the class and pass both the class template pack and the function template pack and verify them in some way? Or can I can add a requires clause to the function that can solve it?

I have found some similar questions, but they are quite old, so there are no answers using concepts.

Is the end goal here to copy lvalues and move rvalues? In that case simply taking all parameters by value can many times be a valid option that simplifies your code. The only loss with that approach AFAIK is that you sometimes get an extra move operation. — super
– super, Commented Jun 26, 2023 at 6:48

Jarod42 · Accepted Answer · 2023-06-27 06:39:46Z

4

Concept std::constructible_from might help:

template <class... C>
class Graph {
public:
    template <typename... Ts>
    requires((std::constructible_from<C, Ts> && ...))
    Graph(Ts&&...);
};

Demo

or more strict std::convertible_to

template <class... C>
class Graph {
public:
    template <typename... Ts>
    requires((std::convertible_to<Ts, C> && ...))
    Graph(Ts&&...);
};

Demo

or std::same_as:

template <class... C>
class Graph {
public:
    template <typename... Ts>
    requires(((std::same_as<Ts&&, C&&>
               || (std::same_as<Ts&&, C&> /*&& !std::is_rvalue_reference_v<C>*/))
            && ...))
    Graph(Ts&&...);
};

Demo

edited Jun 27, 2023 at 6:39

answered Jun 26, 2023 at 6:34

Jarod42

227k15 gold badges214 silver badges350 bronze badges

Sign up to request clarification or add additional context in comments.

8 Comments

Magnar Myrtveit Over a year ago

Thanks. Is the && in Ts&& needed? Also, this allows types that can be created from each other. For example, struct A { int i; }; Graph<A>(42); would be allowed. How can I make it stricter?

Jarod42 Over a year ago

Extra && removed, added another concept more restrictive.(even more restrictive would be with std::same_as)

Magnar Myrtveit Over a year ago

Could you give an example with same_as as well? Just exchanging constructible_from with same_as does not work.

Jarod42 Over a year ago

same_as version added. Unsure if you want to accept rvalue when C contains (l/rvalue) reference...

Magnar Myrtveit Over a year ago

Thanks. I'd like to it to work exactly like f(auto &&...), just with a constraint on the types allowed by auto. The same_as version does not seem to work correctly with const and volatile arguments: godbolt.org/z/acq6EhsfW

|

ecatmur · Accepted Answer · 2023-06-27 12:55:46Z

1

It sounds like what you want is

template<class... C>
class Graph {
public:
    template<class... Ts>
    requires (std::same_as<Ts&, C&> and ...)
    Graph(Ts&&... Context);
};

This exploits reference collapsing rules for concision.

If you want, you can write a concept for this (here written out in full):

template<class T, class U>
concept same_as_or_lvalue_reference_to = std::same_as<T, U> or std::same_as<T, U&>;

template<class... C>
class Graph {
public:
    Graph(same_as_or_lvalue_reference_to<C> auto&&... Context);
};

edited Jun 27, 2023 at 12:55

answered Jun 26, 2023 at 7:34

ecatmur

158k28 gold badges311 silver badges387 bronze badges

3 Comments

Magnar Myrtveit Over a year ago

Thanks! I cannot get the concept solution to work: wrong number of template arguments (1, should be 2).

Magnar Myrtveit Over a year ago

The requires solution is very nice, but it does not work with const: Graph<const int>(42);.

ecatmur Over a year ago

Fixed the concept, was missing an auto. You can fix it for const by using std::remove_const_t and std::remove_cvref_t (not as elegant, though).

Collectives™ on Stack Overflow

Bind both lvalues and rvalues to variadic class template parameter

2 Answers 2

8 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

8 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related