#ifndef _COBSERVER_H_
#define _COBSERVER_H_
class CObserver
{
	public:
	virtual void someChangesInUnderLayer(const std::string& inText) = 0;
};
#endif

under layer:

#ifndef _CUNDERLAYER_H_
#define _CUNDERLAYER_H_
#include <iostream>
#include <string>
#include "CObserver.hxx"
class CUnderLayer
{
	public:
	CUnderLayer(CObserver* inObserver)
	{
		ob = inObserver;
	}
	void changeIt()
	{
		std::cout<<"called by UpperLayer: NO PROBLEM"<<std::endl;
		doSomething();
		ob->someChangesInUnderLayer(internalStr);
	}
	private:
		void doSomething()
		{
			internalStr = "Dosomething in UnderLayer";

		};
		CObserver *ob;
		std::string internalStr;
};
#endif

ober layer

#ifndef _CUPPERLAYER_H_
#define _CUPPERLAYER_H_

#include "CUnderLayer.hxx"

class CUpperLayer : public CObserver
{
	public:
		void someChangesInUnderLayer(const std::string& inText)
		{
			std::cout<<"What is in UnterLayer changed : "<< inText<<std::endl;
		}
};
#endif

main

#include "CUnderLayer.hxx"
#include "CUpperLayer.hxx"

int main()
{
	CUnderLayer under(new CUpperLayer());
	under.changeIt();
	return 0;
}

Nun was ist der Unterschied zwischen callback und observer?

Der Observer, und damit nen polymorphes Object, polymorphes Object -> vtable, vtable -> Funktionspointer (tabelle) ....
Ist einfach die objectorientierte auf C++ zugeschnittene Version davon ^^

wenn dein compiler einigermassen clever (optimierung) und nicht mehr viel hinzukommt, ist ne implementierung mit funktionspointer (callback) und ner einfachen Observer variante im generierten maschinencode gar nicht so unterschiedlich.

Wenn C++ nimmst und damit soweiso auf objektorientierung und Designpattern stehst nimmst Observer klar.

wenn das selbe in c machen musst (oder ne C Schnittstelle bauen musst), keine untzerstuetzung von objecten von der programmiersprache, musst es selber per hand implementieren -> callback.

Ciao ...