Printable View
hey all, i tried to do what is shown in the lesson Template specialization in cprogramming.com...
but i get the following error:
Attachment 12359
what do i do?
moreover i wanted to ask what is the meaning of the tutorial.
is the thing taught in the lesson at all useful?
what will be the consequences if i skip this lesson?
You need the generic class template definition before trying to specialize it.
Read a tutorial on templates if you already haven't.
You can skip this now and learn about it when you need to use it for the first time.
To be able to specialise a template, the compiler needs to see both the template itself, for example ....
as well as the specialisation of that template.Code:template<class T> class alpha
{
// whatever
};
Your code has the specialisation, but not the template that is being specialised. The compiler needs to see both, and will complain bitterly if it doesn't.Code:template<> class alpha<int>
{
// whatever
};
i'd like to make some things clear:
1) I know about templates and the generic class template definition is right on the line 7
2) Mr grumpy. i have done exactly what you have showed in your 2nd example
it doesn't work...
3)Mr manasij7479, i have a knowledge of the templates i learnt it from cprogramming.com...(Check this page: http://www.cprogramming.com/tutorial.html , i am thorough with everything in the "C++ Tutorial, C++ Made Easy: Learning to Program in C++" except the tutorial: Template specialization and partial specialization [thats is why i am asking qs. about the lesson])
PS. if you think that since i have made the template and class definitions on separate lines it wont work.. i have tried it out for normal templates and it does work:
this also works:Code:template <typename T> class x{
//THIS WORKS!
};
Code:template <typename T>
class x{
//THIS WORKS!
};
Then show us the smallest possible compilable example that demonstrates the problem.
No, just the declaration.Quote:
Originally Posted by manasij7479
Simply add the above declaration.Code:// ** This declaration has to be added. **
template <class T>
class Alpha;
...
template <>
class Alpha<int>
{
};
int main()
{
Alpha<int> a1;
// Alpha<long> a2; // This won't work, because Alpha<long> is an incomplete type.
return 0;
}
Didn't know that, thanks.Quote:
Originally Posted by kmdv
That's not the generic template, that's the specialisation, which as others have said needs to come after the generic template definition, or at least its declaration.Quote:
Originally Posted by tennisstar
Then you didn't do exactly what I described.Quote:
Originally Posted by tennisstar
What I described is that the compiler needs to see the template definition BEFORE it sees the specialisation. (or as kmdv pointed out, the declaration before the specialisation).
Thankyou kmdv,
You answered what exactly i was asking...
i made a sample program using the things i understood;
this program should display: INTEGERDOUBLECode:include <iostream>
using namespace std;
template <typename T>
class Alpha;
template <>
class Alpha <int>{
public:
Alpha(){
cout << "INTEGER";
}
};
template <>
class Alpha <double>{
public:
Alpha(){
cout << "DOUBLE";
}
};
int main(){
Alpha <int> a;
Alpha <double> b;
}
one more thing. what i deduced from the lesson is that by using the "template <>" thing, you can cause the template to work in different ways for different datatypes... while normal templates work for all data types but they work the same everytime...
i just wanna know if that assumption is correct...
i also found an alternate method to make your template work in different ways depending on the datatype
here it is:
i just wanna know which way is a better way..Code:#include <iostream>
using namespace std;
template <typename T>
class Alpha{
public:
Alpha(){
if(sizeof(T) == sizeof(int)){
cout << "INTEGER\n";
}else if(sizeof(T) == sizeof(double)){
cout << "DOUBLE\n";
}else if(sizeof(T) == sizeof(char)){
cout << "CHARACTER\n";
}else if(sizeof(T) == sizeof(float)){
cout << "FLOAT\n";
}else{
cout << "DUNNO!";
}
}
};
int main(){
Alpha <int> a1;
Alpha <double> a2;
Alpha <char> a3;
Alpha <float> a4;
Alpha <short> a5;
}
Something like the following would be more reliable than sizeof.
Code:#include<typeinfo>
#include<iostream>
template<typename T>
struct Alpha
{
Alpha()
{
std::cout<<typeid(T).name();
}
};
int main()
{
Alpha<double> foo;
}
Depends on the exact usage scenario.Quote:
Originally Posted by tennisstar
In general the specialized verision will do everything at compile time, thus having slightly better performance.
but use of RTTI is usually a sign of a bad design. I understand the need to see the type at runtime for learning purposes, but in production code, it's generally a bad idea.Quote:
Originally Posted by manasij7479
The former, because it infers no runtime overhead.Quote:
Originally Posted by tennisstar
That's what template specialisation is. There is also partial specialisation, but that's not as common so lets no go there yet.Quote:
Originally Posted by tennisstar
Yuck! Can you imagine if the standard C++ library was like that?Quote:
i also found an alternate method to make your template work in different ways depending on the datatype
here it is:
<snip>
i just wanna know which way is a better way..
First of all, it would not work at all because there are plenty of data types that have the same size, and you can create an infinite number of classes that again have the same size.
Then there's the fact that it is deducing all of what to do at run-time, and the resulting executable would contain the code for every possible data type even if that code is never used.
If you wanted to add something new then you'd have to modify the code! In fact you'd pretty much need to copy and paste the code first, removing the whole benefit of templates.
I'd stop just short of saying that would be the worst possible way to do it, because someone determined could certainly come up with something even worse if given enough time.