template <typename T>
struct rgb{
	T data[3];
	static const int num_channels = 3;
	typedef T channel_value_type;
	rgb(){
		data[0]=data[1]=data[2]=(T)0;
	}

	rgb(const T& v0, const T& v1, const T& v2){
		data[0] = v0;
		data[1] = v1;
		data[2] = v2;
	}
};

template <typename T>
struct gray{
	T intensity;
	gray(const T& v=0) : intensity(v){}
};

template <typename C>
struct calc{
	int num_channels(const C& color){
		return color.num_channels;
	}
};
template <>
struct calc<gray>{
	int num_channels(const gray& color){
		return 1;
	}
};

Mein Problem tritt nun bei der Templatespezialisierung auf. Der Compiler mault da nämlich folgendermaßen rum:

Fehler: Typ/Wert des Arguments 1 passt nicht in Template-Parameterliste für »template<class C> struct calc«
Fehler: einen Typ erwartet, »gray« erhalten

Leider seh ich den Fehler absolut nicht und wollte fragen, ob mir eventuell jemand weiter helfen kann.

Ich bedanke mich schon mal im Vorfeld für eure Antworten und verbleibe

Mit freundlichen Grüßen

gray ist aber kein vollständiger Typ, sondern ein Klassentemplate. Du musst wenn schon gray spezialisiert angeben:

template <>
struct calc<gray<...>>
// ...

template <typename T>
struct calc<gray<T> >{
    int num_channels(const gray<T>& color){
        return 1;
    }
};

template <typename COLOR, typename TYPE>
struct channel{
        TYPE get_channel(const COLOR& color, int i){ 
                return color.data[i];
        }   
};

template <typename TYPE>
struct channel<gray<TYPE> >{
        TYPE get_channel(const gray<TYPE>& color, int i){ 
                return color.intensity; 
        }   
};

Fehler: für »template<class COLOR, class TYPE> struct channel« bereitgestellt
Fehler: falsche Anzahl der Templateargumente (1, sollte 2 sein)

Was mach ich denn falsch?

Mit freundlichen Grüßen

Was mach ich denn falsch?

Du versuchst, channel<gray<TYPE> > zu spezialisieren, aber die Klasse gibt es gar nicht!

Aber channel<gray<TYPE>,TYPE> gibt es:

template <typename TYPE>
struct channel<gray<TYPE>, TYPE>{
        TYPE get_channel(const gray<TYPE>& color, int i){ 
                return color.intensity; 
        }   
};

Falls dich das doppelte TYPE in der Nutzung stört, bleibt dir nichts anderes übrig als eine Helferfunktion zu schreiben

template <typename T> channel<gray<T>, T> make_channel(gray<T>)

Mit freundlichen Grüßen

Kennt jemand vielleicht ein gutes Tutorial?

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf

Kapitel 14 - Templates.

Spaß beiseite - hol dir ein gutes Grundlagenbuch.

Und wie würde ich die Methode get_channel() jetzt aufrufen (Also für einen Gray)?

Mit den entsprechenden Argumenten?

http://www.open-std.org/j ....... ocs/papers/2012/n3337.pdf

GEHT LOS!

#include "color.hpp"                                                                                                                
#include <iostream>
int main(){
    gray<int> *a = new gray<int>();
    a->intensity = 10; 
    std::cout<<channel<int>::get_channel(*a,2)<<std::endl;
    delete a;
    return 0;
}

Das geht nicht! Aber wie geht es dann?

template <template<typename> class COLOR>
struct is_gray{
    template<typename TYPE>
    static TYPE getValue(const COLOR<TYPE>& color, int i)
    {
	return color.data[i];
    }
};

template <>
struct is_gray<gray>{
    template<typename TYPE>
    static TYPE getValue(const gray<TYPE>& color, int i)
    {
	return color.intensity;
    }	
};

template <template<typename> class COLOR, typename TYPE>
TYPE get_channel(const COLOR<TYPE>& color, int i){
    return is_gray<COLOR>::getValue(color, i);
}

Das nutzt jetzt, wenn mich nicht alles täuscht auch Traits-Klassen!

Mit freundlichen Grüßen
DorJo

struct rgb{ 
    T data[3]; 
    static const int num_channels = 3;
    ...

struct gray{
    ...

Warum hat rgb ein Member num_channels und gray nicht, wobei du nachtraeglich zwei Funktionen definierst, die genau diesen Umstand korrigieren. Einfach num_channels auch in gray definieren und 2 Funktionen/Strukturen gespart. Was spricht gegen constexp ?

int main(){ 
    gray<int> *a = new gray<int>(); 
    a->intensity = 10;
     std::cout<<channel<int>::get_channel(*a,2)<<std::endl; 
    delete a;

new und delete in diesem Fall sind einfach verpoent. gray<int> einfach instantiieren ohne Heap ... schon wieder Zeilen gespart.

Beim Namen is_gray erwarte ich eine Funktion/Struktur, die mir angibt, ob die Farbe grau ist, d.h. irgendwie mit bool verknueft ist.

Der erste Template-Parameter von calc ist ein ein vollständiger Typ.

Das ist bloss ein Typ. Vollständig (complete) muss der - jedenfalls im gezeigten Code - nicht sein.

Wieso nicht einfach ein normales Funktionstemplate verwendet wird (statt Memberfunktion/-template), erschliesst sich mir nicht. So ist nur unnötig Redundanz drin.