Also ich habe die Methodenprototypen in einer Header:

class xyz
{
public:
inline	void	set_a	(bool b_sel);
inline	void	set_b	(std::string &_lab);
inline	void	set_c	(std::string &_str);
}

so und das steht in einer CPP, die diese Header eingebunden hat:

void	xyz::set_a	(bool b_sel)
{
	this->_selected_ = b_sel;
}
void    xyz::set_b	(std::string &_lab)		
{
	this->p_text_displayed = new std::string(_label);
}
void	xyz::set_c	(std::string &_str)		
{
	this->p_pathstring = new std::string(_str_path);
}

so und wenn ich jetzt irgendwo die Methoden aufrufe, dann erhalte ich Linker-Fehler, speziell: unresolved external symbol-Fehler.
In der Form:

error LNK2019: unresolved external symbol "public: void __thiscall xyz::set_c(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > &)" ...

so, und wenn ich jetzt bei den Prototypen das "inline" weg lasse, dann bekomm ich die Linkerfehler nicht, warum das?
Ich würde mich über Antworten riesig freuen, danke!

oder

class
{
...  //ohne "inline" keyword
}

inline void	xyz::set_a	(bool b_sel)
{
	this->_selected_ = b_sel;
}
inline void    xyz::set_b	(std::string &_lab)		
{
	this->p_text_displayed = new std::string(_label);
}
inline void	xyz::set_c	(std::string &_str)		
{
	this->p_pathstring = new std::string(_str_path);
}

in Header:

class xyz
{
public:

void	set_a	(bool b_sel);
}

in der CPP:

inline	void	xyz::set_a	(bool b_sel)
{
	this->_selected_ = b_sel;
}

Ich bekomme immer noch den Fehler:

unresolved external symbol "public: void __thiscall xyzm::set_a(bool)"

Bei anderen Methoden funzt das mit dem inline einwandfrei, es ist sogar egal ob das "inline" in der Header steht, oder in der CPP bei der Definition, da gibts keine Probleme, nur mit den 3 angegeben.

Ach ja, und wenn ich sie nach Deiner ersten Methode "richtig" inline mache, also direkt in der Header definiere, dann gibts keine Probleme.

Vielen Dank schonmal!

(oder in Kurzform: Inline-Funktionen MUSST du im Header definieren)

alles in *.h

Der Compiler kann Inline-Funktionen nur auswerten, wenn er die komplette Definition zur Verfügung hat. Von daher wird er eine inline-Deklaration ohne Funktionsrumpf vermutlich ignorieren. Im Ergebnis bringt das inline an dieser Stelle nur etwas für andere Programmierer, die dein Programm lesen.

Genau das meinte ich. Ich hab "dokumentiert" geschrieben. Was ist an "dokumentieren" unklar? Dass ich es nicht für den Compiler "dokumentiere" sondern für Programmierer die den Code lesen sollte klar sein...

Eidt: Und wenn die Funktion so kurz ist, kannst du sie auch gleich in der Klasse definieren.