I have the following simple code:
template <typename T>
struct base
{
std::vector<T> x;
};
template <typename T>
struct derived : base<T>
{
void print()
{
using base<T>::x; // error: base<T> is not a namespace
std::cout << x << std::endl;
}
};
When I compile the code (using GCC-4.7.2) I get the error that you see in the comment above.
I read here: http://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Name-lookup.html#Name-lookup
that
using base<T>::x
has to be included in order to bring in the scope of the base class. Any ideas what is wrong? Thank you in advance!
Put the using declaration in the class definition, not in the function body:
template <typename T>
struct derived : base<T>
{
using base<T>::x; // !!
void print()
{
std::cout << x << std::endl;
}
};
(Of course it's your responsibility to make sure that there's actually an operator<< overload for your std::vector, for example by using the pretty printer.)
You can also make it work if you explicitly say that x is a member:
template <typename T>
struct base
{
std::vector<T> x;
base() : x(1) {}
};
template <typename T>
struct derived : base<T>
{
void print()
{
std::cout << this->x[0] << std::endl;
}
};
int main()
{
derived<int> d;
d.print();
}
Related
#include <functional>
#include <iostream>
class Plain {
public:
template <typename Type>
void member_function(const Type& s) {
std::cout << "Recived: " << s << std::endl;
}
};
template <typename Type>
class Templated : private Plain {
public:
};
int main() {
Plain b;
b.member_function<int>(10); // done!
Templated<int> d;
// d.member_function(); /* how to achive this */
return 0;
}
I am trying to call the member function in class Plain by two method:
createing non-templated class and padding type while calling function
Plain p;
p.member_function<int>();
passing type while creating class and calling without template param
Templated<int> t;
t.member_function(); // achive this
I tried doing binding the function in derived class like
struct Plain{
template<typename T>
static void member_function(const T& s){std::cout << s << std::endl;}
}
template<typename T>
struct Templated : private Plain {
std::function<void(const T&)> print = Templated::Plain::member_function;
}
and after that I was able to do
Templated t<std::string>;
t.print();
When you use private inheritance the methods in Plain are inaccessible to outside code, and you need to have something inside of Templated make the call to the method in Plain; you can do so, or alternatively you could use public inheritance and be able to hit it directly.
class Plain {
public:
template <typename T>
void print(const T & s) {
std::cout << "Received: " << s << std::endl;
}
};
template <typename T>
class Templated : private Plain {
public:
void print(const T & s) {
Plain::print<T>(s);
}
};
template <typename T>
class Alternative : public Plain {};
int main() {
Templated<int> t;
t.print(3); // This could work
Alternative<int> a;
a.print(4); // As could this
return 0;
}
I found a workaround
#include <functional>
#include <iostream>
using namespace std::placeholders;
struct Test {
template <typename Type>
void foo(const Type&) {
std::cout << "I am just a foo..." << std::endl;
return;
}
};
template <typename T>
struct Foo {
private:
Test* obj;
public:
Foo() : obj(new Test) {}
std::function<void(const int&)> foo = std::bind(&Test::foo<T>, obj, _1);
~Foo() { delete obj; }
};
int main() {
Foo<int> me;
me.foo(10);
Test t;
t.foo<int>(89);
std::cout << std::endl;
return 0;
}
Is it possible to create a class template with a member function definition only if the object created is of a specific type?
I've created a template class I will use for storing either int or doubles, but for doubles I would like to be able to set precision too (objects created with myclass < double> should have this functionality, but for myclass< int> there is no need for that to be present at all).
I know I can use a base class template, and create new classes "myInt", "myDouble" using that and implement the functionality only in the myDouble class, but I think it would be cleaner to define the functionality (both the function and a member variable) for doubles in the class template, if that's possible and preferable?
Let's add an example to show what I want to do:
#include <iostream>
#include <iomanip>
class commonBase{
public:
void setState(int state);
virtual void print() = 0;
private:
int _my_state;
};
template <typename T>
class generalObject : public commonBase {
public:
void value(T value);
void print(){ std::cout << "My value: " << _my_value << std::endl; }
private:
T _my_value;
};
template <typename T>
void generalObject<T>::value(T value){
_my_value = value;
}
// Is there any way do specialize only only whats different from the generalObject template?
// Here I thought I could specialize the case where a generalObject is created of <double>, but
// when I do, nothing is derived from generalObject (or at least not visible as far as I can tell)
template<>
class generalObject<double>{
public:
void setPrecision(int precision){ _my_precision = precision; }
// here I would like a special implementation of print(), which overrides the print() in generalObject
// and instead also prints according to the precision set when the object is of <double> type.
// Row below an example which doesn't work (compiler error, _my_value undefined)
void print(){ std::cout << "My value: " << std::setprecision(_my_precision) << _my_value << std::endl; }
private:
int _my_precision;
};
int main(int argc, char* argv[]){
generalObject<int> o1;
o1.value(1);
o1.print();
o1.setState(1); //inherited from the commonBase
generalObject<double> o2;
o2.setPrecision(2);
o2.value(2); //here value isn't available (compile error)
o2.print();
o2.setState(123); //also isn't available (compile error)
}
Sure.
template <typename T> class Poly;
void set_precision(Poly<double>* self, int a) {};
If you really want dot notation you can then add:
template <typename T> class Poly {
public: void set_precision(int a){::set_precision(this,a);}
...
However I think you should think about what you're trying to accomplish. If MyInt and MyDouble have different fields and different methods and different implementations, they should probably be different classes.
This can be solved using template specialization.
We first define a common template...
template< typename T >
struct myclass
{
// common stuff
};
... and specialize that for double:
template<>
struct myclass<double>
{
int precision = 10;
void setprecision( int p ){ precision = p; }
};
Now the setprecision() method can only be called for myclass<double>. The compiler will complain if we try to call it for anything else, like myclass<int>.
int main()
{
myclass<double> d;
d.setprecision( 42 ); // compiles
myclass<int> i;
i.setprecision( 42 ); // fails to compile, as expected
}
Demo.
The basic way to have a member function of a class template exist only for some template parameters is to create a specialization of the class template for those template parameters.
template<typename T>class X{
// general definition
};
template<>class X<double>{
// double-specific definition
};
The downside of this is that the specialization will need to duplicate anything that is common. One way to address this is to move the common things out to a base class template:
template<typename T>class Xcommon{
// common stuff
};
template<typename T>class X: public Xcommon<T>{
// general definition
};
template<>class X<double>: public Xcommon<double>{
// double-specific definition
};
Alternatively, you can do it the other way: put the common stuff in the derived class, and the extras in the base, and specialize the base:
template<typename T>class Xextras{
// empty by default
};
template<typename T>class X: public Xextras<T>{
// common definition
};
template<>class Xextras<double>{
// double-specific definition
};
Either way can work; which is better depends on the details.
Both these methods work for data members and member functions.
Alternatively, you can use enable_if to mean that member functions are not selected by overload resolution if the template parameter doesn't meet a required condition. This requires that the member function is itself a template.
template<typename T>class X{
template<typename U=T> // make it a template,
std::enable_if<std::is_same_v<U,double>> double_specific_function(){
// do stuff
}
};
I wouldn't recommend this option unless there is no other choice.
If the question is about a member function, then here is one of the ways to do it without class template specialization:
#include <iostream>
#include <type_traits>
template <typename T>
struct Type {
template <typename U = T,
typename = typename std::enable_if<std::is_same<U, double>::value>::type>
void only_for_double() {
std::cout << "a doubling" << std::endl;
}
};
int main() {
Type<int> n;
Type<double> d;
// n.only_for_double(); // does not compile.
d.only_for_double();
}
Example on ideone.com
If you require a data-member presence based on the template parameter, you will have to do some kind of specialization, in which case it is, probably, simpler to put the function into corresponding specialization.
EDIT: After OP made his question more specific
Here is one way to do it without extra class and getting rid of virtual functions. Hope it helps.
#include <iostream>
#include <iomanip>
template <typename T, typename Derived = void>
class commonBase {
public:
void setState(int state) {
_my_state = state;
}
void value(T value) {
_my_value = value;
}
template <typename U = Derived,
typename std::enable_if<std::is_same<U, void>::value,
void * >::type = nullptr>
void print() const {
std::cout << "My value: " << _my_value << std::endl;
}
template <typename U = Derived,
typename std::enable_if<!std::is_same<U, void>::value,
void * >::type = nullptr>
void print() const {
static_cast<Derived const *>(this)->_print();
}
protected:
T _my_value;
int _my_state;
};
template <typename T>
class generalObject : public commonBase<T> {
};
template<>
class generalObject<double> : public commonBase<double, generalObject<double>> {
private:
friend commonBase<double, generalObject<double>>;
void _print() const {
std::cout << "My value: " << std::setprecision(_my_precision) <<
_my_value << std::endl;
}
public:
void setPrecision(int precision){ _my_precision = precision; }
private:
int _my_precision;
};
int main(){
generalObject<int> o1;
o1.value(1);
o1.print();
o1.setState(1);
generalObject<double> o2;
o2.setPrecision(2);
o2.value(1.234);
o2.print();
o2.setState(123);
}
Same code on ideone.com
Inheritance and template operator overloading
I don't understand why the operator in A<int> overshadows the operator in base.
It has a different signature after all.
#include <iostream>
struct base {
template <typename U>
void operator()(U&& x) { std::cout << "base" << std::endl; }
};
template <typename T>
struct A: public base { };
template <>
struct A<int>: public base {
void operator()() { std::cout << "A<int>" << std::endl; } // line 1
};
int main()
{
A<double>()(1);
A<int>()(1); // line 2
A<int>()(); // line 3
}
Line 2 does not compile if line 1 is present.
Line 3 does not compile if line 1 is removed (obviously).
If I copy the operator template from base to A, everything works.
I expected the output to be:
base
base
A<int>
The declaration of the operator in the derived class hides the name in the base class.
To solve the issue, it's a matter of a using declaration:
template <>
struct A<int>: public base {
using base::operator();
void operator()() { std::cout << "A<int>" << std::endl; }
};
And both of them will compile.
So, I have a fairly simple set of templates that I want to use together, but the compiler keeps telling me that B::a has incomplete type. Everything is forward declared, but it still doesn't work...
#include <iostream>
using namespace std;
template <typename T> class A;
template <typename T> class B;
template <typename T>
class A{
public:
void ATestFunction();
void CallBFunction();
protected:
B<T> b;
};
template <typename T>
class B{
public:
void BTestFunction();
void CallAFunction();
protected:
A<T> a;
};
template <typename T>
void A<T>::ATestFunction(){
cout << "A was used for a function call" << endl;
}
template <typename T>
void B<T>::BTestFunction(){
cout << "B was used for a function call" << endl;
}
template <typename T>
void A<T>::CallBFunction(){
b.BTestFunction();
}
template <typename T>
void B<T>::CallAFunction(){
a.ATestFunction();
}
int main()
{
A<int> dragons;
dragons.CallBFunction();
return 0;
}
I ask this because I had run into some difficulty programming some array type classes that depend on each other (implementing a two dimensional array that can be accessed like this: [][]), but this problem happened and threw a gear in the works. I made this testing program, but it still fails. I've tried both MinGW 4.7.2 and GNU g++ on Linux, and each gave me the same problem.
The core of the issue can be seen in this piece of code:
template <typename T>
class A{
B<T> b;
};
template <typename T>
class B{
A<T> a;
};
C++ is a language with value semantics, that means that B<T> b; represents an object of type B<T> (rather than a reference, like in Java or C# with reference types). That is, A<T> contains a B<T>. Now if you look at the definition of the B template you see that in turn it contains an A<T> sub object. This is basically impossible, as A<T> cannot possibly contain an object that contains A<T>. What would be the size of an A<T> object?
Without knowing the real problem to solve, I won't venture to recommend an approach, but you can consider using pointers (A<T> would contain a pointer to B<T>, not a full B<T> sub object; or similarly, B<T> could contain a pointer to A<T>; or both), or references. But it might also be the case that a deeper redesign could make more sense.
Even if you used pointers, that could not work. That would basically trigger an infinite loop of A´s and B´s being created
A creates B creates A creates B creates A...
this would work.
#include <iostream>
using namespace std;
template<typename T> class A;
template<typename T> class B;
template<typename T>
class A
{
public:
A()
{
b = new B<T>(this);
}
A(B<T>* pb)
{
b = pb;
}
void ATestFunction()
{
cout << "A was used for a function call" << endl;
}
void CallBFunction()
{
b->BTestFunction();
}
protected:
B<T>* b;
};
template<typename T>
class B
{
public:
B()
{
a = new A<T>(this);
}
B(A<T>* pa)
{
a = pa;
}
void BTestFunction()
{
cout << "B was used for a function call" << endl;
}
void CallAFunction()
{
a->ATestFunction();
}
protected:
A<T>* a;
};
int main()
{
A<int> dragons;
dragons.CallBFunction();
B<int> bdragons;
bdragons.CallAFunction();
return 0;
}
or maybe just using static functions
#include <iostream>
using namespace std;
template<typename T> class A;
template<typename T> class B;
template<typename T>
class A
{
public:
static void ATestFunction()
{
cout << "A was used for a function call" << endl;
}
void CallBFunction();
};
template<typename T>
class B
{
public:
static void BTestFunction()
{
cout << "B was used for a function call" << endl;
}
void CallAFunction();
};
template<typename T>
void A<T>::CallBFunction()
{
B<int>::BTestFunction();
}
template<typename T>
void B<T>::CallAFunction()
{
A<int>::ATestFunction();
}
int main()
{
A<int> dragons;
dragons.CallBFunction();
B<int> bdragons;
bdragons.CallAFunction();
return 0;
}
The concept of variadic templates is quite confusing to me and I want to make it a bit more complex (well I think...).
Let us consider the following code:
template <typename T>
class base
{
template <typename... E>
virtual void variadic_method_here(E... args) = 0;
};
and an implementing class:
class derive : public base<some_object>
{
void variadic_method_here(concrete_args_here);
};
How do I do that?
I think if I were faced with this problem I'd use CRTP and overloads to solve the problem.
e.g.:
#include <iostream>
template <typename Impl>
class base {
public:
template <typename... E>
void foo(E... args) {
Impl::foo_real(args...);
}
};
class derived : public base<derived> {
public:
static void foo_real(double, double) {
std::cout << "Two doubles" << std::endl;
}
static void foo_real(char) {
std::cout << "Char" << std::endl;
}
};
int main() {
derived bar;
bar.foo(1.0,1.0);
bar.foo('h');
}
You can't have a templated virtual function.