(I had no idea how to name this question and I couldn't find anything similar. Sorry if this is duplicate)
If I want to inherit from some base template class, I can do this that way:
template<typename A=int, typename B=char> class C {};
template<typename... Args> class D : public C<Args...> {}; //it works!
This way I can change in project passed parameters to template class C and I don't have to change every usage of class D. Great. But what if I have template class using not only types as parameters but also values? For example:
template<int dim=3, typename float_t=double> class GeometricObject{};
template<typename... Args> class Point : public GeometricObject<Args...>{}; //it doesnt work
Of course I could define last template with integer type on the beginning. But this is not a way, if I would have 100 different classes all inheriting from GeometricObject and then I would change default dim value to 2, I would have to change every single class definition.
I also hope that there is the way without using any #define, #else and similar preprocessor commands. I know that templates are in fact also preprocessor commands, but... well, let's be modern here ;)
You can not mix type and non-type parameters in a template parameter pack. But it seems that your Point and other derived classes don't need to access the parameter pack arguments separately. In such cases it's easier, as well as more semantically correct, to pass the base class:
template<int dim=3, typename float_t=double> class GeometricObject{};
template<class GeometricObject=GeometricObject<>> class Point : public GeometricObject{};
Instantiating a Point could then look like:
Point<> a{}; // the same as Point<GeometricObject<>> a{};
Point<GeometricObject<4>> b{};
Point<GeometricObject<2, float>> c{};
Of course the GeometricObject<...> could be typedef'd to something shorter. Also, it can be made to look like a namespace instead of providing parameters to each geometric object separately:
template<int dim = 3, typename float_t = double>
struct GeometricObjects {
using Base = GeometricObject<dim, float_t>;
using Point = ::Point<Base>;
// ...
};
using TwoDim = GeometricObjects<2>;
TwoDim::Point a{};
I suppose you have multiple template classes and you want your Point object to be able to inherit from them all.
Instead of doing:
template <typename ... Args>
class Point : public GeometricObject<Args...>{};
I would instead do:
template <typename T>
class Point : public T {};
Now we just have to define proper traits to access the types template parameters in case they are needed. These types should be factored into a std::tuple (for instance).
The burden to fill this trait is on the GeometricObject class. For example, with your definition we would have:
template <typename T>
struct type_parameters;
template <int N, typename Float>
struct type_parameters<GeometricObject<N, Float> {
typedef std::tuple<Float> types;
};
The main scenario: a method of Point needs the type template parameters of GeometricObject (to forward them to a method of GeometricObject). To achieve this, you will have to pass in a tuple that will be unfold to call the inner method. To do so I make use of features added in the STL for C++14. You could still rewrite them yourself but I spared me the hassle for this question...
template <typename T>
class Point : public T {
template <typename Method, typename ... Args, std::size_t ... Is>
auto call_unfold(Method method, std::tuple<Args...> const& tuple, std::integer_sequence<std::size_t, Is...>) {
return (this->*method)(std::get<Is>(tuple)...);
}
template <typename Method, typename Tuple>
auto call_unfold(Method method, Tuple const& tuple) {
return call_unfold(method, tuple, std::make_index_sequence<std::tuple_size<Tuple>::value>());
}
public:
typedef typename type_parameters<T>::types types;
void some_method(types const& args) {
return call_unfold(&T::some_method, args);
}
};
This example is quite meaningless but the same technique could be useful with constructors of Point that need to call a base class constructor.
A live demo showing how it works is available on Coliru
Ok, so I figured it out how I should include variable-type template parameters into tuples. Basically I need to 'encapsulate' them into new parameter. This example works perfectly well AND solves my problem:
#include <type_traits>
template<int n = 2> struct Dim {
const int dim = n;
};
template<typename T> class SillyBaseClass {
public:
typedef typename T dim;
};
template<typename... Args> class SillyDerivedClass : public SillyBaseClass<Args...>{
public:
typedef typename SillyBaseClass::dim dim;
SillyDerivedClass() {
static_assert(std::is_same<dim,Dim<2>>::value,
"Number of dimensions must be equal to 2");
}
};
int main() {
SillyDerivedClass<Dim<2>> Class2d; //this works
SillyDerivedClass<Dim<3>> Class3d; //this returns expected error
}
Related
I am new in Abstract classes so please excuse any ignorant mistakes
The exercise is given from my school, so the main.cpp file is to be used, almost as it is
I am trying to create a simple calculator in Eclipse using C++11
There exists a simple Abstract class with two virtual methods.
The two derived classes are simply the "Result" and the "Const" classes.
This is the header file of the Abstract class called
Expression.h
class Expression
{
public:
Expression();
virtual ~Expression();
//methods
};
Following is the source file of Expression
Expression.cpp
#include "expression.h"
#include <iostream>
Expression::Expression(){}
Expression::~Expression(){}
Then I have created two classes called Const and Result
Const.h
#include <iostream>
#include "expression.h"
class Const : public Expression
{
public:
Const(int value);
//inherited methods
private:
int value;
};
and the source file
Const.cpp
#include "expression.h"
#include "Const.h"
Const::Const(int x)
{
value=x;
};
//inherited methods
Result.h
#include <iostream>
#include "expression.h"
#include "Const.h"
class Result : public Expression
{
public:
Result(Const& c);
//inherited methods
private:
double value;
};
Result.cpp
#include "expression.h"
#include "Result.h"
Result::Result(Const& c)
{
value=c.point;
};
//inherited methods
So what i need is to understand
main.cpp
#include <iostream>
#include "expression.h"
#include "const.h"
#include "result.h"
void testResult()
{
Result res (new Const(4));
//Here an inherited method will be used to print the contents of object res
}
int main()
{
testResult();
return 0;
}
The problem i can't solve is the line
Result res (new Const(4));
The error i get is
Conversion from 'Const* to non-scalar type 'Result' requested
The thing is that what is described in this line should be used as it is, and i can't seem to find exactly what it is.
EDIT
The question as asked firstly was apparently misleading due to my fault, tried to fix the question so as to describe exactly my problem
You started correctly, by creating a common base class for both Const and Result, but then completely ignored it.
All your problems are indeed in this line:
Result res = (new Const(4));
First of all, operator new in C++ returns a pointer, not a reference. Also, this would be a good place to make use of your base class:
Expression* res = new Const(4);
Since you declared methods evaluate() and print() as virtual, the object res is pointing to will be correctly resolved as an instance of Const when you call res->print() or res->evaluate().
This will use Const version of print(). If you want to use the Result version - abstract classes won't help you here, you need to use casting. Create your own operator=(Const &) in Result or operator Result() in Const.
If you had two derived classes DerivedClass1 and DerivedClass2 both derived from some BaseClass then to instantiate a pointer to a DerivedClass1 and use it in polymorphic way use:
BaseClass* p = new DerivedClass1;
To create a base class pointer to a DerivedClass2 use:
BaseClass* p = new DerivedClass2;
And not the:
DerivedClass1* p = new DerivedClass2;
In your example both Result and Const classes are derived from Expression class hence the confusion. To pass in an argument of SomeClass& type, create a temporary object of SomeClass and pass it in:
SomeClass o;
someFunction(o);
One issue is that
double point= value;
doesn't initialize your member, but a new unused local variable.
just do
point = value;
Class Result and Const are two different classes. This means the type conversion
Result *res = (new Const(4));
is not possible. To do what you want, since both classes inherit from Expression, do:
Expression * res = new Result( objConst);
Where objConst is a Const object.
Is it possible to use the using keyword for aliasing a template template parameter?
template <template<int> class T>
struct Foo {
using type = T;
};
Thanks
using (or typedef) always provide an alias for a type, never for an higher-kinded type (template template parameter). What you can do is templatize the alias itself on the int:
template <template<int> class T>
struct Foo {
template <int X>
using type = T<X>;
};
In situations, when you have a base and many derived classes, all of which encode a variadic pack, something like the following
template<typename ... Args>
struct base
{};
template<typename ... Args>
struct derived_1: base <Args...>
{};
template<typename ... Args>
struct derived_2: base <Args...>
{};
How does one check if objects of different derived classes were instantiated using the same pack. For instance given
derived_1<int,float,double> d1_obj;
derived_2<int,float,double> d2_obj;
I want a mechanism to tell me that both objects are equal, in the sense that they contain the same types in the same order.
You can do this using template template parameters and partial specialization for when arguments match:
template <class T, class U>
struct same_args : std::false_type{};
template <template <typename...> class T, template <typename...> class U,
typename... Ts>
struct same_args<T<Ts...>, U<Ts...>> : std::true_type{};
Then same_args<derived_1<int,float>, derived_2<int,float>>::value will be true.
Live Demo
Given a decorator class with standard decorator CTOR
explicit TheDecorator(std::unique_ptr<BaseClass> &&p_rrBase);
I want to create a member variable that is a unique ptr of such a decorator. I thus tried
unique_ptr<DerivedClass> spToDeco(make_unique<DerivedClass>() ); // class to decorate
m_spDecoration = make_unique<TheDecorator>( move(spToDeco) ); // unique ptr of decorator
Using VS 2010 and Scott Meyers implentation of make_unique (without variadic templates, implementing both a version with zero and one argument(s) instead), I get the error
error C2780: _Ty &&std::forward(...): expects 1 argument -- 0 provided
which I understand, as "TheDecorator" expects the argument to forward. But where the heck do I have to code it into, how do I form the syntax correctly? Am I supposed to include a move in the <> brackets? Thanks a lot for help!
Make_Unique:
namespace std
{
template<typename T>
std::unique_ptr<T> make_unique()
{
return std::unique_ptr<T>( new T() );
}
template<typename T, typename Ts>
std::unique_ptr<T> make_unique(Ts&& params)
{
return std::unique_ptr<T>( new T(std::forward<Ts>()) );
}
}
EDIT 2: SOLVED already, it must read
template<typename T, typename Ts>
std::unique_ptr<T> make_unique(Ts&& params)
{
return std::unique_ptr<T>( new T(std::forward<Ts>(params)) );
}
In this test:
#include <string>
struct thing {
std::string name_;
};
class test {
thing id_;
public:
test(thing id) : id_{std::move(id)} {}
};
I would expect struct thing to have an implicit move constructor, so that class test can use std::move() to initialise its data member.
Clang version 3.4.1 gives this error:
error: no viable conversion from 'typename remove_reference<thing&>::type' (aka 'thing') to 'std::string' (aka 'basic_string<char, char_traits<char>, allocator<char> >')
The problem can be solved by adding a move constructor to struct thing, which of course means that a converting constructor and an explicitly defaulted copy constructor also needs to be added.
I do not understand why I cannot move struct thing around implicitly.
You are using a brace initialization - id_{std::move(id)}. In your case, as though struct thing is a POD (plain old data) it means, that C++ compiler tries to initialize the first member - std::string name_ instead of using a default constructor of struct thing object. Read more about aggregates and PODs.
In this case, because of the braces, class test's constructor is equivalent to something like this:
class test {
thing id_;
public:
test(thing id) {
id_.name_ = std::move(id); // Notice that this causes
// the "no viable conversion" error
}
};
Solution 1: You need to declare explicitly that you want to use a default struct thing's constructor by using parenthesis instead of braces:
#include <string>
struct thing {
std::string name_;
};
class test {
thing id_;
public:
test(thing id) : id_(std::move(id)) {} // Default c-tor will be used
};
Solution 2: You could also declare a user-defined constructor of struct thing to make it non-POD:
#include <string>
struct thing {
std::string name_;
thing(thing&&) {} // Used-defined move constructor
};
class test {
thing id_;
public:
test(thing id) : id_{std::move(id)} {} // You can use braces again
};