ich habe eine Klasse:

template <class T> 
class FSPoint
{
    private:

        vector<T>           m_values;

    public:

        /** Copy Constructor
         * @param const FSPoint &
         */
        FSPoint( const FSPoint& other );

        /** Getter for value 
         * @return f
         */
        vector<T> &values();      
};

In der Implementierung des Copy-Constructors stosse ich auf massive Probleme:

template <class T> 
    FSPoint<T>::FSPoint( const FSPoint& other )
    {
        set_values( other.values() );
    }

Ich bekomme den Fehler:

Member function 'values' not viable: 'this' argument has type 'const Meanshift::FSPoint<double>', but function is not marked const

Was ich nicht verstehe: ich verändere doch das Objekt 'other' nicht, wenn ich eine Referenz auf eine Member-Variable erhalte? Das gleiche passiert, wenn ich statt der Referenz das Objekt direkt übergebe. Warum also der ganze Krampf mit const etc.?

Kann mir jemand sagen, was ich hier übersehe? Danke!

vector<T> &values();
const vector<T> &values() const;

Was ich nicht verstehe: ich verändere doch das Objekt 'other' nicht, wenn ich eine Referenz auf eine Member-Variable erhalte?

Für den Compiler schon - weil du keinerlei Anstalten gemacht hast, ihm das mitzuteilen. Siehe Cookies Beitrag: Wenn du eine Methode als const deklarierst, weiß und überprüft der Compiler, dass sie an dem Objekt nichts ändert, auf dem sie aufgerufen wird. Wenn du die const-Deklaratoin aber weglässt, muss der Compiler davon ausgehen, dass das Objekt dadurch verändert wird - egal was in der Definition steht (die muss er ja nichtmal unbedingt kennen).

In deinem Fall muss der Compiler also davon ausgehen, dass values() dein other ändert, das widerspricht aber dem const other& => Fehler.

template <class T> 
    FSPoint<T>::FSPoint( const FSPoint& other )
    {
        set_values( other.values() );
    }

Besser wäre übrigens:

template <class T> 
    FSPoint<T>::FSPoint( const FSPoint& other )
    : m_values(other.m_values)
    {
    }