http://www.linuxselfhelp.com/HOWTO/C++Programming-HOWTO-18.html oder Boost nehmen.
class Thread
{
public:
Thread();
virtual ~Thread();
// Startet die Methode run() in einem eigenen Thread
int start();
// Threadroutine, wird von start()/entry() in einem
// eigenen Thread gestartet
virtual void run() = 0;
// true wenn run gerade in einem eigenen thread ausgefuerhrt weird
bool running();
// Wartet auf die Beendigung des Threads
int join();
// Freigeben der Ressourcen, siehe pthread_detach
int detach();
private:
// Eintrittspunkt fuer das Starten des Threads
// nimmt this als Argument, und fuert dann
// run aus, wird von start() benutzt
static void* entry(void* me);
private:
Thread(const Thread&);
pthread_t threadId;
bool state;
};
Thread::Thread()
{
// create something
state = false;
threadId = 0;
}
Thread::~Thread()
{
// destroy something
if ((threadId != 0) && (state))
{
pthread_cancel(threadId);
}
}
bool Thread::running()
{
return state;
}
void* Thread::entry(void* me)
{
//Thread* pthis = dynamic_cast<Thread*>(me);
//Thread* pthis = static_cast<Thread*>(me);
Thread* pthis = (Thread*)(me);
// soll immer und ueberall gecancelt werden koennen
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,0);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
pthis->state = true;
pthis->run();
pthis->state = false;
return 0;
}
int Thread::start()
{
return pthread_create(&threadId, 0, Thread::entry, (void*)this);
}
int Thread::join()
{
if ((threadId != 0) && (state))
{
return pthread_join(threadId, 0);
}
return -1;
}
int Thread::detach()
{
if (threadId != 0)
{
return pthread_detach(threadId);
}
return -1;
}
Naja, es gibt ein paar komische Leute, die der Ansicht sind, man solle /bin/sh auf die Lieblingsshell versymlinken. Das halte ich persönlich für großen Blödsinn und man läuft damit Gefahr, viele Sachen kaputtzumachen, wenn die eigene Lieblingsshell nicht Bash oder eine Bourne-Shell ist.
Außerdem gibt es für solche Späße ja den Login-Shell-Eintrag in /etc/passwd. Der Shebang legt einfach nur (per Absolutpfad) den Interpreter fest; die Login-Shell des Users wird also ignoriert, ich nehme an, dass der von Dir gelesene Text sich auf genau das oben beschriebene Verhalten bezieht.
ah wieder was neues dazugelernt
(Bin noch relativ auf neuen Pfaden in der Linuxprogrammierung)
hab gleich man die man - Seite angeschaut bezüglich des Befehls ich sollte mir mal ein kleines schlaues Büchlein zusammentippseln mit commandos, die ich schon verwendet habe)
es gibt eine grundlegende API für die graphische Schnittstelle: xlib. Aber sie ist vor allem schwer und aufwändig zu verwenden. Deshalb greift man auf Frameworks wie QT oder GTK+, um sich nicht mit xlib rumzuschlagen. Sowohl in QT als auch in GTK+ ist so eine MessageBox schnell gemacht.
Ist es gefährlich sich auf strlen zu verlassen?
Nur, wenn du die Nullterminierung vergessen hast.
Lösung: Nullterminierung nicht vergessen.
Muss ich bei Funktionseintritt von rein internen Funktionen, die von außen nicht aufgerufen werden, wirklich immer alle Parameter prüfen?
Natürlich nicht. Ein assert kann im Debugmodus aber trotzdem nie was schaden.
Kann man sich auf die Ergebnisse von Systemaufrufen verlassen? Also wenn das Feld d_namlen in einem struct dirent sagt "5", dass der Name auch wirklich fünf Zeichen lang ist?
Wie sollte auch nur das simpelste Programm funktionieren, wenn man sich auf so etwas nicht verlassen könnte?
Also ich habe mir gerade mal bei Amazon das Buch "Programming with POSIX Threads" von David R. Butenhof bestellt. 65€ sind zwar kein Pappenstiel, aber ich habe vielerorts gelesen dass es DAS Buch für Multithreadding ist...
Danach sehen wir weiter
Mod? Failed! schrieb:
Bin ich froh, dass das Niveau hier hoch ist
Ich finde es niveauvoller, stark umgangssprachliche Formulierungen zu benutzen, als sich zum Stänkern abzumelden.
hi
nimm die opencv library, dammit kannst du sehr wohl ein (frame) von deiner usb cam bekommen. Die library giebt auch für linux.
Ein bisschen in die lib einarbeiten, und schon kannst du sehr einfach avi files erzeugen.
Wen es immer noch nicht will, dann haperts an deinem ergeits, oder den grundlagen.
Lowbyte
Schau mal, ob Du da nicht irgendwo den Namen des Compilers direkt eingeben kannst. Wenn nicht, verwendest Du pferdefreunds Tip und versymlinkst einfach so, dass bei Eingabe von gcc gcc-4.1 aufgerufen wird, also ungefähr so:
ln -sf /usr/bin/gcc-4.1 /usr/bin/gcc
Aber bevor Du das tust, probier bitte, ob man Matlab nicht irgendwo einfach den genauen Namen der gcc-Binary geben kann.
Man sollte wenn möglichst, keine Bibliotheken oder Programme selbst kompilieren. Installier dir lieber libtar mit der Paketverwaltung. Dann wird libtar automatisch geupdatet und du erhältst eine funktionierende Version.
sudo apt-get install libtar-dev
Hi
ich nutze ein SharedMemory Segment in meinem Programm. Dort mach ich an einer bestimmten Stelle einen fork() und anschließend einen execl() um ein neus Programm auszuführen.
In diesem möchte ich mir jetzt das SharedMem.Segment wieder anhängen. Den Key gebe ich mir dafür mit. shmget/shmat funktionieren auch ohne fehlermeldung. Nur sobald ich dann die Daten darin verwenden möchte reagiert das Progamm nicht mehr. Es stürzt nicht ab, es passiert blos gar nix mehr.
Mir sind die Ideen ausgegangen, woran das liegen kann, damit greife ich auf das Segmetn im neue Programm zu:
Acces shared memory segment
long shrdMem_key = atol(argv[2]);
//Get the shared memory segment
if ((shrdMem_id = shmget(shrdMem_key, 0, 0644)) < 0) //Get the shared memory segment
{printf("shmget fail\n");exit(1);}
SessionInfo **sms = (SessionInfo**) shmat(shrdMem_id, 0, 0);
if (*sms < 0) {printf("attach fail\n");exit(1);}
int slot = atoi(argv[3]);
//Jetzt sollte es ja da sein und verwendet werden können
printf("Session-ObPid: %d\n", sms[slot]->getPid());
//Bei der ersten Verwendung geht irgendwas in die Hose.....
Hab es jetzt mal soweit hinbekommen (umgebungsvarialben).
Jedoch jetzt das Problem, dass sich das ausgeführte Programm nach einigen Millisekunden mittem in der Initialisierung beendet. Einen fehler des Programms kann ich zu 100% auschließen. Augerufen wird das programm mit system("myapp &") damit, es im hintergrund weiterläuft.
Jemand schon ein ähnliches Problem gehabt?
Das ist halt die Stärke eines durchdachten File-Systems. Unter C kannst du einfach einen File-Pointer auf /dev/ttyS0 aufmachen und da rein schreiben und raus lesen wie aus einer Datei.
Unter Linux ist eben alles ein bißchen einfacher als auf diesem weitverbreiteten anderen Betriebssystem
Hallo, wir haben Performancetests für ein von uns geschriebenes Programm durchgeführt.In diesem Programm wird oft dynamisch Speicher angefordert und wieder zurückgegeben. Dabei ist uns folgendes aufgefallen:
Ab einer bestimmten Größe zu allokirenden Speichers (128kB) nimmt die Geschwindigkeit des Programmes stark ab.
Dies könnte nach unseren Vermutungen daran liegen, dass ab dieser Größe der Aufruf mmap() statt brk() vorgenommen wird.
Seltsamerweise steigt die Geschwindigkeit wieder ab 256 kB auf das normale Tempo an.
(Testreihen, bei denen mmap() deaktiviert ist, sind noch nicht fertig, aber die bisherigen Ergebnisse lassen vermuten, dass keine Geschwindigkeitsschwankungen auftreten, auch im Quellcode (C) ist keine Sonderbehandlung für bestimmte Speichergrößen vorgesehen)
Kann man das irgendwie erklären?