für mich handle ist wie ein pointer, was auf eine interne Struktur zeigt, aber man kann nicht durch den pointer direkt auf member zugreifen, muss man immer mit lock und unlock machen.
Wie wird ein handle erzeugt? und wie sieht memory managerment aus?

Ich verstehe weder deinen Text wirklich, noch (von dem was ich hinein interpretiere) irgendeinen Sinn darin. Ich gehe einfach davon aus das du hier viele Informationen vorenthältst, die für eine Antwort sinnvoll sind (oder dir die nötigen Deutschkenntnisse fehlen um es richtig zu beschreiben).

Was soll beispielsweise dein lock/unlock machen (für mich hört sich das nach irgendwelchen Sperrmechanismen an)? Memory Management ist auch sehr weiträumig um dir deine Frage zu beantworten usw.

für mich handle ist wie ein pointer, was auf eine interne Struktur zeigt, aber man kann nicht durch den pointer direkt auf member zugreifen, muss man immer mit lock und unlock machen.
Wie wird ein handle erzeugt? und wie sieht memory managerment aus?

Die Idee eines Handles hast du ja bereits selbst beschrieben. Im Endeffekt kann ein Handle einfach ein Integer sein der durchnummeriert wird und auf eine (interne) Liste deiner Resourcen verweisst. Durch die Indirektion hast du dann keinen direkten Zugriff mehr auf deine Objekte.
Ein sehr einfaches Beispiel:

#include <string>
#include <iostream>
#include <map>

typedef unsigned int handle_t;

class FoobarManager;

class Foobar
{
	friend class FoobarManager;

public:
	const std::string &GetName() const { return m_name; }

private:
	explicit Foobar(const std::string &name)
		: m_name(name)
	{
	}

	std::string m_name;
};

class FoobarManager
{
	typedef std::map<handle_t, Foobar> handleList;

public:
	FoobarManager() : m_lastHandle(0)
	{
	}

	handle_t CreateFoobar(const std::string &name)
	{
		m_handles.insert(std::make_pair(m_lastHandle, Foobar(name)));
		return m_lastHandle++; // überlauf beachten ;)
	}

	void PrintHandleToConsole(handle_t handle)
	{
		handleList::const_iterator it = m_handles.find(handle);
		if (it != m_handles.end()) {
			std::cout << it->second.GetName() << std::endl;
		}
	}

private:
	handleList m_handles;
	handle_t m_lastHandle;
};

int main (void)
{
	FoobarManager manager;
	handle_t hfoobar1 = manager.CreateFoobar("hallo welt");
	handle_t hfoobar2 = manager.CreateFoobar("foobar");
	manager.PrintHandleToConsole(hfoobar1);
	manager.PrintHandleToConsole(hfoobar2);
}

super erklärt, eine andere frage:
jedesmal wenn man new aufrufen, verursacht memory fragment, kann man irgendwie durch handle dies vermeiden?

Kannst du deinen Satz nochmal korrekt formulieren? So mit Subjekt, Prädikat, danach Objekt? Und korrekter Deklination und Konjugation? Ich habe keine Ahnung was eigentlich die Frage ist, bloß dass sie irgendwas mit "new", "handle" und "vermeiden" zu tun hat.

super erklärt, eine andere frage:
jedesmal wenn man new aufrufen, verursacht memory fragment, kann man irgendwie durch handle dies vermeiden?

Das hat implizit nichts mit dem Konzept "Handle" zu tun. Das gehört eher in den Bereich "Memory allocation/management". Da könntest du Speicherfragmentierung z.B. umgehend indem du Memorypools verwendest, oder Ähnliches...

Klingt wie mit einem Uebersetzungstool ...

Google Rückübersetzung nach Englisch schrieb:

every time you call new, causing memory fragment, one can handle somehow avoid this?

Google Rückübersetzung nach Französisch schrieb:

chaque fois que vous nouvel appel, provoquant fragment de mémoire, on peut manipuler en quelque sorte d'éviter cela?

Die beiden sind es wohl nicht im Original, wobei das Englisch schon fast verständlich ist (weil man das "handle" als Verb auffassen kann). Und außer den beiden kann ich nur noch Latein.

@Threadersteller: Viele hier verstehen auch andere Sprachen, falls dir das lieber ist. Jedenfalls verstehen wir das besser als falsches Deutsch.

Das hat implizit nichts mit dem Konzept "Handle" zu tun. Das gehört eher in den Bereich "Memory allocation/management". Da könntest du Speicherfragmentierung z.B. umgehend indem du Memorypools verwendest, oder Ähnliches...

wie kann man eine Application in einem bestimmten memory block laufen lassen?
z.B.

int* m = new int [10];

dann die &m ist vom platform memory managerment abhängig, man kann es nicht kontrollieren.

Nehmen wir an, ich will alle Allokationen die Adressen zwischen 0x1000 ~ 0xf000 haben, alleine mit "new" od "alloc" kann man es nicht schaffen.

Wie macht man es?

placement new?

aber was sollte man dann schreiben?

placement new?

aber was sollte man dann schreiben?

Dann machst du new (/*Adresse zwischen 0x1000 und 0xf000*/) Typname . Und dann fliegt dir das zu 99.9999% um die Ohren, weil diese Adressen entweder nicht gemapt sind ( Segmentation fault) oder an dieser Stelle schon wer weiß was steht ( irgendein lustiger Absturz). Wenn du mit festen Adressen hantieren willst, musst du schon ganz genau wissen, was du da tust und musst auch einen sehr guten Grund dafür haben.

Du könntest einen eigenen Memory Manager programmieren, der einen festen Speicherblock bekommt und in diesem Block Objekte erzeugt.
Was genau hast du denn vor?

das ist genau was ich vorhabe.

der einen festen Speicherblock bekommt

schreibt man einfach

int* i = 0xffff000; ?

Wenn du mit festen Adressen hantieren willst, musst du schon ganz genau wissen, was du da tust und musst auch einen sehr guten Grund dafür haben.

memory fragment ist z.b. ein grund

schreibt man einfach

int* i = 0xffff000; ?

netrobot schrieb:

memory fragment ist z.b. ein grund

Ich glaube du solltest lieber keinen Speichermanager schreiben.

Zum Beispiel werden die Ergebnisse der Messungen gleichzeitig in einem Diagramm, Balkendiagramm und Tabelle angezeigt. Preise ändern sich ständig. Informationen über Diagramme stellen diese Änderungen dauerhaft das Messobjekt, haben aber keine Kenntnisse über die Struktur der Daten.