Zitat

Original geschrieben von Phlow
huh .. na gegen BSD hat hier sicher keiner was ... wie kommst du drauf.

Und du bekommst auch alle Linux Distributions (ausser die aktuellste SUSE) immer gratis als iso zum download.

bei den 49€ zahlst nämlich hauptsächlich die Handbücher.

Ah jo, ich würde dir das Buch "FreeBSD unleashed" empfehlen, ist sehr gut geschrieben und gibts im LMZ

Du bekommst auch die aktuellste SuSE immer gratis als Download. Nur meistens mit ein paar Wochen Verzögerung.

Vollständige ISO gibts aber keine - Du musst entweder den ganzen FTP Tree runterladen und dann zB ein NFS Install machen, oder du lädst Dir die 10 MB große Boot ISO runter und machst ein FTP Install, das funktioniert problemlos ...

Du musst natürlich auf jedem PC, auf dem du Deine Software laufen lassen willst, die BDE installieren.

Die BDE kann _nicht_ statisch gelinkt werden, was einer der Hauptkritikpunkte war.

In neueren Versionen der Borland Entwicklungsumgebungen wird die BDE langsam aber sicher von DBExpress abgelöst werden.

Nun zur Frage, wie Du die BDE installierst: Bei Delphi sollte eine abgespeckte Version von Installshield dabei sein. Da musst du dann ankreuzen, dass dein Programm die BDE verwendet, und es packt automatisch alle nötigen DLLs usw in das Setup Archiv, IIRC.

Von Hand gehts wahrscheinlich auch, ist aber ziemlich sicher gewaltig mühsam.

HTH

Zitat

Original geschrieben von mmartin
Jetzt weiss ich zumindest (für mich) das der Nächste Kauf/Download kein SuSE sein wird denn die sollten zumindest solche Sachen dazugeben.

Zumindest weiss jetzt wonach ich suchen muss

Ähem, Du kleiner Witzbold Wie soll SuSE gtk+2 inkludieren, wenn es zum Zeitpunkt der Veröffentlichung von SuSE 8.0 noch nicht fertiggestellt war?

Bei SuSE 8.1 ist es natürlich dabei ...

Also ich bin sehr zufrieden mit meinem SuSE 8.0, und ich hab schon so ziemlich jede Linux Distribution ausprobiert (mit Ausnahme von Gentoo, das muss ich zugeben).

Ich kann Dir nur soviel sagen, dass Du für die Eclipse IDE mit gtk+ Widgets gtk+2 brauchst, nicht gtk+.

gtk+2 ist bei Suse 8.0 noch nicht dabei, da es zu neu ist und Suse kein Interesse an gtk+ und dem Gnome Desktop hat.

Runterladen kannst Du gtk+2 unter http://www.gtk.org.

Das ist dann natürlich zum selber kompilieren. Sollte aber kein Problem sein, wenn Du ein bisschen Ahnung hast.

HTH

Zitat

Original geschrieben von catwoman

aufruf lautet
Klasse::statischeMethode();

lg
ines

Das ist natürlich richtig, hab mich vertippt

Danke.

Zitat

Original geschrieben von Dave2003
Hi Jeremy!

Klingt einleuchtend
(Keine Klassenbibliothek)

Und wo du dich so toll auskennst, hab ich gleich noch eine Frage. Und zwar im Task selbst drin. Entweder so:

//----------------------------------------
// CLASS
//----------------------------------------

class Task
{
public:
Task();
~Task();

private:
static void Change(int nZahl);
int nNumber;
};

//----------------------------------------
// GLOBAL
//----------------------------------------

Task *pTask = NULL;

//----------------------------------------
// Task::Task
//----------------------------------------

Task::Task()
{
pTask = this;
}

//----------------------------------------
// Task::Change
//----------------------------------------

void Task::Change(int nZahl)
{
pTask->nNumber = nZahl;
}

== oder ==

//----------------------------------------
// CLASS
//----------------------------------------

class Task
{
public:
Task();
~Task();
void Change(int nZahl);

private:
int nNumber;
};

//----------------------------------------
// IMPLEMENTATION
//----------------------------------------

void Change(nZahl);

//----------------------------------------
// GLOBAL
//----------------------------------------

Task *pTask = NULL;

//----------------------------------------
// Task::Task
//----------------------------------------

Task::Task()
{
pTask = this;
}

//----------------------------------------
// Task::Change
//----------------------------------------

void Task::Change(int nZahl)
{
nNumber = nZahl;
}

//----------------------------------------
// Change
//----------------------------------------

void Change(int nZahl)
{
pTask->Change(nZahl);
}

(Ich hoff da stecken jetzt keine Fehler drin)
Also ums aufs Wesentliche zu bringen: was bewirkt das von dir bereits angesprochene Wörtchen static im private bereich? Irgendwelche Vor- oder Nachteile oder eventuell tut-man-nicht-Programmierstile?
Was ist also vernünftiger von diesen beiden Varianten?

Ich hoffe du kannst mir auch hierbei helfen

David

Alles anzeigen

Folgendes:

Mir ist nicht ganz klar, wozu der globale Zeiger pTask gut sein soll ... Falls du sicherstellen willst, dass nur genau eine Instanz der Klasse erstellt wird, rate ich Dir, mal in Google nach "Singleton Pattern" zu suchen.

Um zu beantworten, was static tut:
Dieses Schlüsselwort ist ziemlich vielfältig. So, wie Du es eingesetzt hast, bewirkt es, dass eine Methode, auf die der static Modifier angewendet wird, nicht auf einer Instanz der Klasse angewendet werden kann, sondern quasi nur einmal, nämlich für die Klasse selbst, existiert. Man kann sie dann so aufrufen:
Klasse:statischeMethode();
aber nicht:
Klasse a;
a.statischeMethode();

Wiederum eine andere Bedeutung hat static im Rumpf einer Funktion. Dort bedeutet es, dass eine mit static deklarierte Variable sozusagen einen "Memory-Effekt" hat, dh, beim nächsten Aufruf der Funktion hat die Variable noch den Wert, den sie beim letzten Aufruf der Funktion zugewiesen bekam.

Bsp.:

void doSomething()
{
static int a = 15;
std::cout << a << std::endl;
a *= 2;
}

doSomething();
> 15
doSomething();
> 30

usw.

Welche Variante jetzt konkret besser ist, kann ich Dir leider nicht sagen, für mich wirken beide etwas seltsam. Falls Du genauer spezifizieren kannst, was Du machen willst, können wir Dir sicher weiterhelfen.

Zitat

Original geschrieben von Dave2003
Hi!

Nehmen wir an ich habe eine Class namens Task. Was ist vernünftiger:

Task cTask;
int nResult;

nResult = cTask.Run();
return nResult;

-- oder --

Task *pTask = new Task;
int nResult;

pTask = new Task;
nResult = pTask->Run();
delete pTask;

return nResult;

Wo liegen bei diesen beiden die feinen Unterschiede?

Alles anzeigen

Ich weiß leider nicht, um (und ob) welche Klassenbibliothek es sich hier handelt.

Aber mal ganz allgemein:

Die erste Variante legt die Variable auf dem Stack ab, die zweite alloziert Speicher aus dem Freispeicher (Heap).

Tendenziell ist es für größere Objekte empfehlenswert, diese im Heap anzulegen, da der Speicherplatz im Stack sonst knapp werden könnte.

Eine "bessere" Variante in dem Sinn gibt es also nicht, es kommt ganz auf die Situation an.

Beachte auch, dass Objekte, die im Heap gespeichert sind, explizit wieder freigegeben werden müssen (mittels delete).

Objekte, die im Stack angelegt sind, haben (so sie nicht static deklariert werden) ihr Leben hingegen am Ende des Codeblocks verwirkt

Je nach Klassenbibliothek gibt es aber auch Vorschriften (zB VCL) oder Empfehlungen, wie neue Objekte instanziiert werden sollten.

HTH,

Jeremy

Zitat

Original geschrieben von MaxAuthority
ich glaub du meinst atoi();

und einen einzelnen char kannst du ja einfach umrechnen.

*PLONK*

Und schon der erste Fehler. atoi() ist böse, ein programm, in dem atoi() vorkommt, wird in sysprog nicht angenommen.

http://www.vmars.tuwien.ac.at/courses/sysprog/Richtlinien.html

Statt dessen ist strtol() zu verwenden (siehe man 3 atoi für eine begründung).

Hat hier auch problemlos funktioniert ...

GTK+ ist zwar für Windows frei erhältlich, ABER:
Das Programm sieht dann halt nicht wie ein Windows Programm aus, sondern hat eben den GTK+ Look. Für mich ist sowas weder als Programmierer noch als User akzeptabel.

Welche Bereiche und Funktionen GTK+ außer GUI abdeckt, kann ich leider nicht beantworten, da ich noch nie mit GTK+ gearbeitet habe (bis auf minimale Versuche).

Keine Ahnung, wie Opera implementiert ist ...

wxWindows ist vielleicht von der Idee her Qt überlegen, dafür finde ich es wesentlich unangenehmer zu benutzen (sprich: WxWindows besteht zu großen Teilen aus Macros und lässt eine schön abstrakte, objektorientierte Schnittstelle missen, ähnlich wie MFC).

Qt ist - zumindest unter Unix - ebenfalls OpenSource, und kann je nach belieben unter der QPL oder unter der GPL verwendet werden.

Hier noch die Standardantwort aus comp.lang.c zu diesem Thema ...

http://www.eskimo.com/~scs/C-faq/q13.16.html

[EDIT]:
Für jeden nichttrivialen Anwendungsfall empfehle ich zur Generierung von Zufallszahlen, entweder, einen eigenen Generator zu schreiben, oder zumindest jenen aus der BOOST Bibliothek zu verwenden.

http://www.boost.org/libs/random/index.html

Die meisten Implementierungen von srand(), rand() und co. sind nämlich meistens miserabel.

Qt zeichnet die Widgets unter Windows selbst. IOW, die ganzen Widgets werden mit den Qt eigenen Canvas Klassen, etc. gezeichnet.

Das hat den Vorteil, dass auf den diversen Plattformen nur die Canvas Klasse mit Hilfe der OS spezifischen Grafikfunktionen implementiert werden muss.

Allerdings sehen Qt basiert Programme wirklich *genau* so aus, wie native Windows Programme. Es werden sogar Windows XP Themes unterstützt, wie das genau funktioniert, weiß ich aber nicht.

Qt 2.3 steht in einer non-commercial Version auch für Windows gratis zur Verfügung.

Als Alternative zu Qt kann ich auch Wx Windows empfehlen (http://www.wxwindows.org/). Allerdings ist diese Library den MFC sehr ähnlich, und AFAIK erstreckt sich der crossplatform Support auch nur auf die Entwicklung des User Interface.

Mir persönlich war Qt wesentlich sympathischer.

Eine Variante wäre auch noch, einen Portability Layer zu verwenden.

Beispielsweise könntest Du mit Cygwin unter Windows entwickeln, und somit POSIX Funktionen für Verzeichnisoperationen, etc. verwenden. Dann könntest Du das Programm unter Unix nativ kompilieren, und unter Windows eben mit Hilfe von Cygwin, das eine POSIX Schnittstelle um das Windows API anbietet.

Alternativ sei auch noch Qt erwähnt, eine crossplatform Library, die von Userinterface bishin zu Dateioperationen usw. unter Unix, Windows und MacOS X eine einheitliche Schnittstelle anbietet - also genügt eine einzige Codebasis für die 3 Plattformen.

Wenn Dein Programm nicht zu viel plattformspezifischen Code enthält, würde ich es aber einfachhaltshalber so machen, wie MaxAuthority es vorgeschlagen hat.

Bezüglich gcc:
http://www.gnu.org/manual/glibc-2…tem%20Interface

Unter Windows:
http://msdn.microsoft.com/library/defaul…t_functions.asp
-> FindFirstFile() et al.

Die MFC (die Klassenbibliothek von Visual C++) wird wohl noch eigene Funktionen für sowas zur Verfügung stellen. Da ich jedoch nicht mit Visual C++ arbeite, konnte ich Dir nur die relevanten Windows API Funktionen raussuchen.

ISO/ANSI C++ unterstützt nur eine minimale Anzahl an Operationen auf Dateien, und das Konzept eines Verzeichnisses kommt im Standard AFAIK nicht einmal vor.

Das heißt jetzt nicht, dass es keine Möglichkeit gibt, die gewünschten Operationen auszuführen; allerdings ist die Lösung abhängig vom verwendeten Compiler/dem verwendeten Betriebssystem/der verwendeten Klassenbibliothek.

Eine Lösung, die dem Standard entspricht, gibt es nicht.

Wenn Du uns sagst, welche Entwicklungsumgebung Du verwendest, können wir Dir wahrscheinlich weiterhelfen.

mfg,

Jeremy

Hi,

Ich les das Ganze leider erst ein bisschen spät, wie's aussieht.

Prinzipiell wär ich aber sehr interessiert, an sowas mitzuwirken.

Ich hab auch schon ab und zu mal ein bisschen rollengespielt.

Mit 3D Programmierung hab ich leider nichts am Hut, dafür hab ich ziemlich gute C++ Kenntnisse und würde vor allem gerne beim Unix/Linux Teil helfen (hab aber auch einige Erfahrung mit Windows Entwicklung).

- Jeremy