Hi,
hier kommt das erste kleine C++ Problem für diese Woche: Ich möchte aus einer Datei eine Zahl einlesen. Also habe ich ersteinmal den Betreffenden Bereich der Datei in ein char Array geschrieben, was ja auch funktioniert (daher das cout << RAM). Besser wäre es jedoch wenn das Array ein *RAM[] wäre (ähnlich wie *argv[]). Nur weiss ich leider nicht, wie man in ein solches Array schreiben kann. Ein char *RAM[8]; (...) RAM[8] = fgetc(ptr); gibt folgerichtig ein Segmentation fault. Gibt es eine Möglichkeit das Array so anzulegen? Oder gibt es vielleicht auch eine Möglichkeit ein normales Array (RAM[8]) in eine int Zahl umzuwandeln?
#include <iostream.h> #include <stdio.h> #include <stdlib.h>
int main(int argc,char **argv) { char RAM[8]; FILE *ptr; ptr = fopen("/proc/meminfo","r"); fseek(ptr,166,0); for(int i=0; i<=8; i++) { RAM[i] = fgetc(ptr); cout << RAM[i]; } fclose(ptr); return 0; }
Das Programm soll mir die Menge des vorhandenen Hauptspeichers aus der /proc/meminfo zur Weiterverarbeitung auslesen.
On Mon, Jan 14, 2002 at 06:13:07PM +0100, Steffen Liebergeld wrote:
Hi,
hier kommt das erste kleine C++ Problem für diese Woche: Ich möchte aus einer Datei eine Zahl einlesen. Also habe ich ersteinmal den Betreffenden Bereich der Datei in ein char Array geschrieben, was ja auch funktioniert (daher das cout << RAM). Besser wäre es jedoch wenn das Array ein *RAM[] wäre (ähnlich wie *argv[]). Nur weiss ich leider nicht, wie man in ein solches Array schreiben kann. Ein char *RAM[8]; (...) RAM[8] = fgetc(ptr); gibt folgerichtig ein Segmentation fault. Gibt es eine Möglichkeit das Array so anzulegen? Oder gibt es vielleicht auch eine Möglichkeit ein normales Array (RAM[8]) in eine int Zahl umzuwandeln?
Also mal zum Zusammenhang zwischen Pointern und Arrays:
Bsp. a) Ich defininiere einen Array von chars
char myarray[8];
die Variable myarray ist jetzt logischerweise vom Typ char* und zegt auf den Anfang des Arrays. Das erste und zweite Element koennte ich jetzt so beschreiben
char *pc = myarray; *pc = 'a'; pc++; *pc = 'b';
Bsp. b) Jetzt definieren wir einen zweidimensionalen Array
char myarray[8][8];
Jetzt haengt der Typ von der Betrachtungsweise der einzelnen Elemente ab. i) Wenn ich ein konkretes Element haben will, gebe ich "Spalte" und "Zeile" an:
myarray[1][5] = 'a'; //typ char
ii) Wenn ich nur die "Zeile" angebe, erhalte ich einen char* (analog Bsp. a))
char* pc = myarray[0]; strncpy(pc, "Hello\n", 8);
Der Pointer zeigt dann auf den Anfang des "Subarrays"
ii) Wenn ich nur myarray angebe, erhalte ich einen char** (lies: Pointer auf einen Pointer). D.h. myarray zeigt auf den Anfang des Arrays (ist also ein char*), der seinerseits wieder aus Unterarrays besteht, d.h. jedes Element davon ist (siehe a)) ein char*. Deswegen ist myarray vom Tp char**.
Das sollte deine Frage dann beantworten. Das Konzept ist am Anfang etwas schwer zu verstehen, ergibt aber zum Schluss Sinn. :)
cu, Ulf
Am Montag, 14. Januar 2002 19:10 schrieben Sie:
On Mon, Jan 14, 2002 at 06:13:07PM +0100, Steffen Liebergeld wrote:
Hi,
[Problem mit Arrays]
Also mal zum Zusammenhang zwischen Pointern und Arrays:
Bsp. a) Ich defininiere einen Array von chars
char myarray[8];
die Variable myarray ist jetzt logischerweise vom Typ char* und zegt auf den Anfang des Arrays. Das erste und zweite Element koennte ich jetzt so beschreiben
char *pc = myarray; *pc = 'a'; pc++; *pc = 'b';
Bsp. b) Jetzt definieren wir einen zweidimensionalen Array
char myarray[8][8];
Jetzt haengt der Typ von der Betrachtungsweise der einzelnen Elemente ab. i) Wenn ich ein konkretes Element haben will, gebe ich "Spalte" und "Zeile" an:
myarray[1][5] = 'a'; //typ char
ii) Wenn ich nur die "Zeile" angebe, erhalte ich einen char* (analog Bsp. a))
char* pc = myarray[0]; strncpy(pc, "Hello\n", 8);
Der Pointer zeigt dann auf den Anfang des "Subarrays"
ii) Wenn ich nur myarray angebe, erhalte ich einen char** (lies: Pointer auf einen Pointer). D.h. myarray zeigt auf den Anfang des Arrays (ist also ein char*), der seinerseits wieder aus Unterarrays besteht, d.h. jedes Element davon ist (siehe a)) ein char*. Deswegen ist myarray vom Tp char**.
Das sollte deine Frage dann beantworten. Das Konzept ist am Anfang etwas schwer zu verstehen, ergibt aber zum Schluss Sinn. :)
OK, das habe ich jetzt verstanden. Danke für die aufschlussreichen Ausführungen. Jetzt habe ich noch ein weiteres Problem mit Arrays (oder eher mit globalen und lokalen Variablen):
Mit globalen char Arrays (RAM[8]) läuft das Program ohne Probleme, wenn ich die Arrays allerdings lokal deklariere (siehe unten), dann endet das Program mit einem Segmentation fault. Theoretisch dürfte es aber doch gar keine Probleme geben oder hab ich da was übersehen?
// Gibt den Betrag des Arbeitsspeichers aus /proc/meminfo aus double getRAM(FILE * ptr) { char RAM[8]; //<---hier steckt das Problem fseek(ptr, 166, 0); for (int i = 0; i <= 8; i++) { RAM[i] = fgetc(ptr); } return strtod(RAM,NULL); }
Wird vielleicht das Array schon vor der Rückgabe gelöscht (vor return ...)?
On Mon, Jan 14, 2002 at 09:46:28PM +0100, Steffen Liebergeld wrote:
double getRAM(FILE * ptr) { char RAM[8]; //<---hier steckt das Problem fseek(ptr, 166, 0); for (int i = 0; i <= 8; i++) { RAM[i] = fgetc(ptr); } return strtod(RAM,NULL); }
Wird vielleicht das Array schon vor der Rückgabe gelöscht (vor return ...)?
Ich bin immer noch der Meinung, daß Du ein Zeichen zu viel einliest. Ich halte folgendes für etwas günstiger:
char RAM[8]; // außerdem, Großbuchstaben sind ziemlich // unüblich für sowas // Du hast 8 Zeichen, also RAM[0] .. RAM[7].
// for (int i = 0; i < 8); ++i) { for (int i = 0; i < sizeof(RAM); ++i) { RAM[i] = fgetc(ptr); }
Nicht wegen des "sizeof()", das ist nur Kosmetik und Hilfe bei späteren Änderungen, aber relativ wichtig kommt mir das "<" an Stelle des "<=" vor. Eben "*Fast* getroffen ist auch daneben.".
Heiko
On Mon, Jan 14, 2002 at 09:46:28PM +0100, Steffen Liebergeld wrote:
Mit globalen char Arrays (RAM[8]) läuft das Program ohne Probleme, wenn ich die Arrays allerdings lokal deklariere (siehe unten), dann endet das Program mit einem Segmentation fault. Theoretisch dürfte es aber doch gar keine Probleme geben oder hab ich da was übersehen?
Die Loesung hat ja Heiko schon gegeben. Da es dem Compiler grundsaetzlich egal ist, ob du bei einem 8-er Array das 10. Element beschreibst, gibt das bei globalen Variablen keine Probleme, er ueberschreibt halt andere Variablen (Hauptsache der Speicher gehoert dir), bei lokalen hingegen gehoert dir hier der Speicher eben nicht...
cu, Ulf
On Mon, Jan 14, 2002 at 06:13:07PM +0100, Steffen Liebergeld wrote:
hier kommt das erste kleine C++ Problem für diese Woche:
Willst Du C++ machen, oder C? Viele Teile Deines Programmes sehen aus eher wie C. Will nicht sagen, daß das verkehrt ist, aber es macht Dir eventuell das Leben unnötig schwer.
Ich möchte aus einer Datei eine Zahl einlesen. Also habe ich ersteinmal den Betreffenden Bereich der Datei in ein char Array geschrieben, was ja auch
{ char RAM[8];
Nun, ich habe das Gefühl, Du liest ein Zeichen zu viel ein. "char RAM[8]" schafft Dir ein Array von 8 Zeichen, also Index 0 bis 7. Du liest dann aber mit i von 0 bis i <= 8, also ist i irgendwann auch mal 8, und Du liest dann immer noch ein, also nach RAM[8], das gibt's aber nicht mehr. Glückssache, wenn das funktioniert:
for(int i=0; i<=8; i++) { RAM[i] = fgetc(ptr); cout << RAM[i]; }
"Off by one" wird gern genommen ;-)
Hier ist mal eine Alternative:
#include <iostream> #include <fstream> #include <string>
using namespace std;
const string MEMFILE = "/proc/meminfo";
int main(int argc,char **argv) { int size = 0; string unit;
ifstream memfile(MEMFILE.c_str()); cout << MEMFILE << endl;
// Ich nehme an, Du willst die Zeile mit MemTotal haben. // Da ich mir nicht sicher wäre, daß das immer an Position 166 // losgeht (bei mir z.B. nicht, weil ich mehr Speicher habe), würde // ich entweder bis Zeile 4 lesen und mich dann beginnen zu kümmern, // oder noch flexibler, ich würde so lange Worte lesen, bis ich // "MemTotal:" finde, und dann davon ausgehen, daß das nächste Wort // die Speichergröße ist.
string current; while (memfile >> current) { if (current == "MemTotal:") { memfile >> size >> unit; break; } }
if (!size) { cerr << "Offenbar kein Speicher vorhanden." << endl; exit(1); }
cout << "Größe: " << size << " " << unit << endl;
return 0; }
// vim:sts=4 sw=4 aw ai sm:
Am Montag, 14. Januar 2002 19:30 schrieben Sie:
On Mon, Jan 14, 2002 at 06:13:07PM +0100, Steffen Liebergeld wrote:
hier kommt das erste kleine C++ Problem für diese Woche:
Willst Du C++ machen, oder C? Viele Teile Deines Programmes sehen aus eher wie C. Will nicht sagen, daß das verkehrt ist, aber es macht Dir eventuell das Leben unnötig schwer.
Naja, ich habe einfach die Funktionen aus den Manpages genommen. Aber deine Lösung sieht einfacher aus.
Ich möchte aus einer Datei eine Zahl einlesen. Also habe ich ersteinmal den Betreffenden Bereich der Datei in ein char Array geschrieben, was ja auch
{ char RAM[8];
Nun, ich habe das Gefühl, Du liest ein Zeichen zu viel ein. "char RAM[8]" schafft Dir ein Array von 8 Zeichen, also Index 0 bis 7. Du liest dann aber mit i von 0 bis i <= 8, also ist i irgendwann auch mal 8, und Du liest dann immer noch ein, also nach RAM[8], das gibt's aber nicht mehr. Glückssache, wenn das funktioniert:
upps
for(int i=0; i<=8; i++) { RAM[i] = fgetc(ptr); cout << RAM[i]; }"Off by one" wird gern genommen ;-)
Hier ist mal eine Alternative:
#include <iostream> #include <fstream> #include <string>
using namespace std;
const string MEMFILE = "/proc/meminfo";
int main(int argc,char **argv) { int size = 0; string unit;
ifstream memfile(MEMFILE.c_str()); cout << MEMFILE << endl; // Ich nehme an, Du willst die Zeile mit MemTotal haben. // Da ich mir nicht sicher wäre, daß das immer an Position 166 // losgeht (bei mir z.B. nicht, weil ich mehr Speicher habe), würde // ich entweder bis Zeile 4 lesen und mich dann beginnen zu kümmern, // oder noch flexibler, ich würde so lange Worte lesen, bis ich // "MemTotal:" finde, und dann davon ausgehen, daß das nächste Wort // die Speichergröße ist. string current; while (memfile >> current) { if (current == "MemTotal:") { memfile >> size >> unit; break; } } if (!size) { cerr << "Offenbar kein Speicher vorhanden." << endl; exit(1); } cout << "Größe: " << size << " " << unit << endl; return 0;}
Wenn ich mir das ansehe, überkommt mich die Gewissheit dass ein gutes Buch zum Thema nun wohl doch angebracht ist. Könnt ihr mir da ein besonders gutes empfehlen? Gibt es auch Bücher, wo Qt oder Gtk mit behandelt werden? Woher bekomme ich Dokumentation zu den Standartfunktionen (ausser "man xyz"). Ich bräuchte ein Buch, welches einen Einstieg vermittelt aber auch quasi Hilfe zur Selbsthilfe bietet, also kein stupides Abtippen von Tutorial - Anwendungen. Wenn man dann richtig tief ins Thema eintaucht wäre mir das auch recht.
On Mon, Jan 14, 2002 at 10:07:40PM +0100, Steffen Liebergeld wrote:
Willst Du C++ machen, oder C? Viele Teile Deines Programmes sehen aus eher wie C. Will nicht sagen, daß das verkehrt ist, aber es macht Dir eventuell das Leben unnötig schwer.
Naja, ich habe einfach die Funktionen aus den Manpages genommen. Aber deine Lösung sieht einfacher aus.
Stimmt, es gibt kaum/keine Manpages zur STL (Standard Template Library). Ich hab' hier ein Buch (na ja, auch noch andere) "The C++ Standard Template Libraray" von Nicolai M. Josutties. (Allerdings nicht unbedingt Beginners Lektüre. Vielleicht kannst Du Dir sowas wie "GoTo C++" (A. Willms) antun. Das habe ich immer als Grundlage in C++-Schulungen genommen. Ist nicht alles drin, aber man lernt damit Laufen.
mal 8, und Du liest dann immer noch ein, also nach RAM[8], das gibt's aber nicht mehr. Glückssache, wenn das funktioniert:
upps
... wie Du ja in Deinem zweiten Beispiel (mit der lokalen Variable in einer weiteren Funktion) gesehen hattest.
[Bücher]
Habe ich ja oben schon was aufgeschrieben. Zu Qt gibt's wohl inzwischen auch was brauchbares. Aber ich kenne die nicht. Hab' hier noch ein älteres von O'Reilly (aber dafür mit den Unterschriften der Qt-Entwickler), das ist nicht mehr überall aktuell und im Wesentlichen findet man die Inhalte auch im Qt-Tutorial (das mit Qt kommt).
Qt-Dinge die ich in letzter Zeit sah, hatten fast immer gleich was mit KDE zu tun ...
Heiko
Am Dienstag, dem 15. Januar 2002 um 08:14:37, schrieb Heiko Schlittermann:
Stimmt, es gibt kaum/keine Manpages zur STL (Standard Template Library).
Es gibt das stl-manual, die libstdc++3-doc und die c-cpp-reference.
Torsten
On Mon, Jan 14, 2002 at 07:30:08PM +0100, Heiko Schlittermann wrote:
string current; while (memfile >> current) { if (current == "MemTotal:") { memfile >> size >> unit; break; } }
Ich will jetzt nicht zu sehr einen auf nitpicker machen, und mit strings sieht das zugegebenermassen viel schoener aus, aber bei groesseren Bloecken hab ich irgendwo mal gelesen, dass das Auslesen einer Datei in der Form relativ langsam ist (was ja technisch auch nachvollziehbar ist), deswegen sollte man das bei groesseren Bloecken nicht machen, sondern mittels char[].
cu, Ulf
On Mon, Jan 14, 2002 at 10:19:48PM +0100, Ulf Lorenz wrote:
On Mon, Jan 14, 2002 at 07:30:08PM +0100, Heiko Schlittermann wrote:
string current; while (memfile >> current) { if (current == "MemTotal:") {Ich will jetzt nicht zu sehr einen auf nitpicker machen, und mit strings sieht
Ich will auch nicht auf Nitpicker antworten, aber wenn er /proc/meminfo auslesen will, scheinen mir das keine große Blöcke zu sein.
das zugegebenermassen viel schoener aus, aber bei groesseren Bloecken hab ich irgendwo mal gelesen, dass das Auslesen einer Datei in der Form relativ langsam ist (was ja technisch auch nachvollziehbar ist), deswegen sollte man das bei groesseren Bloecken nicht machen, sondern mittels char[].
Hm. Ich bin mir auch nicht sicher,
o ob ich dann für viele Dinge Perl oder andere Scriptsprachen verwenden dürfte.
o ob es überhaupt eine Überlegung wert ist, wenn der verwendete Code nicht in einem zeitkritischen Pfad liegt.
o ob ich es mit getchar() oder Assembler ;-) effizienter hinbekommen würde.
o was teurer ist: eine zusätzliche Stunde Programmieraufwand oder einfach ein schnellerer Rechner.
Nur so Gedanken.
Heiko
Komisch, bisher hat sich niemand über die Signatur von Bernd Ledig aufgeregt... Nächster Versuch:
Am Montag, dem 14. Januar 2002 um 18:13:07, schrieb Steffen Liebergeld:
Das Programm soll mir die Menge des vorhandenen Hauptspeichers aus der /proc/meminfo zur Weiterverarbeitung auslesen.
Mach' einfach ein
echo 1 > /proc/sys/vm/overcommit_memory
dann hast du richtig viel Speicher! ;-)
Nun gut, Heiko hat dir schon eine sinnvolle Antwort gegeben. Aber im Ernst, die Abfrage des "verfügbaren" Hauptspeicher sieht nach einem Denkfehler aus. Wozu brauchst du das?
Torsten
Am Montag, 14. Januar 2002 20:19 schrieben Sie:
Komisch, bisher hat sich niemand über die Signatur von Bernd Ledig aufgeregt... Nächster Versuch:
Am Montag, dem 14. Januar 2002 um 18:13:07, schrieb Steffen Liebergeld:
Das Programm soll mir die Menge des vorhandenen Hauptspeichers aus der /proc/meminfo zur Weiterverarbeitung auslesen.
Mach' einfach ein
echo 1 > /proc/sys/vm/overcommit_memory
dann hast du richtig viel Speicher! ;-)
Nun gut, Heiko hat dir schon eine sinnvolle Antwort gegeben. Aber im Ernst, die Abfrage des "verfügbaren" Hauptspeicher sieht nach einem Denkfehler aus. Wozu brauchst du das?
Ich hab mir ein kleines Programm geschrieben, welches mir auf der Commandozeile den vorhandenen, benutzten, gepufferten usw. Speicher ausgibt (Und die Prozente des Hauptspeichers). Es ist im Grunde nur ein kleines Programm um etwas mehr c++ zu lernen, aber das Ergebnis ist gar nicht so unpraktisch;-)
Die Ausgabe sieht jetzt ungefähr so aus: Hauptspeicher: 511.539 MB (100%) Freier Speicher: xxxxxx MB (xxx%) Puffer: xxxxxx MB (xxx%) Cache: xxxxxx MB (xxx%) Used: xxxxxx MB (xxx%)
On Tue, Jan 15, 2002 at 02:39:33PM +0100, Steffen Liebergeld wrote:
Am Montag, 14. Januar 2002 20:19 schrieben Sie:
Komisch, bisher hat sich niemand über die Signatur von Bernd Ledig aufgeregt... Nächster Versuch:
<schnipp>
Ich hab mir ein kleines Programm geschrieben, welches mir auf der Commandozeile den vorhandenen, benutzten, gepufferten usw. Speicher ausgibt (Und die Prozente des Hauptspeichers). Es ist im Grunde nur ein kleines Programm um etwas mehr c++ zu lernen
Sah eher nach C aus
aber das Ergebnis ist gar nicht so unpraktisch;-)
Die Ausgabe sieht jetzt ungefähr so aus: Hauptspeicher: 511.539 MB (100%) Freier Speicher: xxxxxx MB (xxx%) Puffer: xxxxxx MB (xxx%) Cache: xxxxxx MB (xxx%) Used: xxxxxx MB (xxx%)
Ich habe mir auch eins geschrieben: -------------------------- #!/bin/bash cat /proc/meminfo --------------------------
Die Ausgabe sieht jetzt so aus: total: used: free: shared: buffers: cached: Mem: 31883264 29900800 1982464 44523520 2453504 19017728 Swap: 127954944 0 127954944 MemTotal: 31136 kB MemFree: 1936 kB MemShared: 43480 kB Buffers: 2396 kB Cached: 18572 kB SwapTotal: 124956 kB SwapFree: 124956 kB
SCNR
Ciao, Tobias
On Tue, Jan 15, 2002 at 07:10:36PM +0100, Tobias Koenig wrote:
On Tue, Jan 15, 2002 at 02:39:33PM +0100, Steffen Liebergeld wrote:
Ich hab mir ein kleines Programm geschrieben, welches mir auf der
...
(Und die Prozente des Hauptspeichers). Es ist im Grunde nur ein kleines Programm um etwas mehr c++ zu lernen
Ich habe mir auch eins geschrieben:
#!/bin/bash cat /proc/meminfo
Aber Du hast dabei nichts über C++ gelernt! Meine ersten C/C++-Programme sahen jedenfalls noch einfacher aus. Deine sicher auch.
Heiko
On Wed, Jan 16, 2002 at 12:03:45PM +0100, Heiko Schlittermann wrote:
On Tue, Jan 15, 2002 at 07:10:36PM +0100, Tobias Koenig wrote:
On Tue, Jan 15, 2002 at 02:39:33PM +0100, Steffen Liebergeld wrote:
Ich hab mir ein kleines Programm geschrieben, welches mir auf der
...
(Und die Prozente des Hauptspeichers). Es ist im Grunde nur ein kleines Programm um etwas mehr c++ zu lernen
Ich habe mir auch eins geschrieben:
#!/bin/bash cat /proc/meminfo
Aber Du hast dabei nichts über C++ gelernt! Meine ersten C/C++-Programme sahen jedenfalls noch einfacher aus. Deine sicher auch.
Yepp, war ein Hello-World-Programm, wie wohl jeder mal angefangen hat. Ich meinte nur, das Steffen lieber erstmal ordentliches Parsen mit C (scanf) hätte machen sollen.
Ciao, Tobias
On Wed, Jan 16, 2002 at 07:17:56PM +0100, Tobias Koenig wrote:
Yepp, war ein Hello-World-Programm, wie wohl jeder mal angefangen hat. Ich meinte nur, das Steffen lieber erstmal ordentliches Parsen mit C (scanf) hätte machen sollen.
Warum? Vielleicht auch ordentliche Assembler-Programmierung zuerst.
Heiko
Am Donnerstag, dem 17. Januar 2002 um 15:33:58, schrieb Heiko Schlittermann:
Vielleicht auch ordentliche Assembler-Programmierung zuerst.
Quatsch, die paar Binärcodes hat man im Kopf und gibt sie in einem Hex-Editor ein!
Zu KC85-Zeiten haben wir das tatsächlich gemacht, mit POKE in den Speicher und mit CALL gestartet. Die häufigsten Codes wusste man irgendwann auswendig... ;-)
Torsten
On Thu, Jan 17, 2002 at 08:25:40PM +0100, Torsten Werner wrote:
Zu KC85-Zeiten haben wir das tatsächlich gemacht, mit POKE in den Speicher und mit CALL gestartet. Die häufigsten Codes wusste man irgendwann auswendig... ;-)
Ihr habt sowas gemacht? ;-) 0xC9 war RET, glaube ich.
Heiko
Hi Heiko.
On Thu, Jan 17, 2002 at 20:34:32 +0100, Heiko Schlittermann wrote:
Ihr habt sowas gemacht? ;-) 0xC9 war RET, glaube ich.
0xC9 _ist_ RET. Yeah! Z80-Power! ;-)))
Nostalgische Gruesse, Chris
Am Dienstag, 15. Januar 2002 19:10 schrieben Sie: [bla bla]
aber das Ergebnis ist gar nicht so unpraktisch;-)
Die Ausgabe sieht jetzt ungefähr so aus: Hauptspeicher: 511.539 MB (100%) Freier Speicher: xxxxxx MB (xxx%) Puffer: xxxxxx MB (xxx%) Cache: xxxxxx MB (xxx%) Used: xxxxxx MB (xxx%)
Ich habe mir auch eins geschrieben:
#!/bin/bash cat /proc/meminfo
Die Ausgabe sieht jetzt so aus: total: used: free: shared: buffers: cached: Mem: 31883264 29900800 1982464 44523520 2453504 19017728 Swap: 127954944 0 127954944 MemTotal: 31136 kB MemFree: 1936 kB MemShared: 43480 kB Buffers: 2396 kB Cached: 18572 kB SwapTotal: 124956 kB SwapFree: 124956 kB
*rofl* Das war mir natürlich auch bekannt. Aber was kann man denn aus dieser Datei so als Mensch ablesen? Die Angaben in kb mögen ja bei geringen Menge Arbeitsspeicher noch akzeptabel sein, aber einfacher zu lesen ist es natürlich in MB. Und wenn man es dann auch noch grafisch macht, hat man auch eine Vorstellung von den Grössenverhältnissen.
Ausgabe der letzten Version: ~ > meminfo a |#########-------------------------------------------------------------------| Hauptspeicher: 511.539 MB (100%) Freier Speicher: 400.008 MB (78.1969%) Puffer: 4.67969 MB (0.914825%) Cache: 48.7539 MB (9.53083%) Used: 58.1016 MB (11.3582%)
oder kurz: ~ > meminfo |#########-------------------------------------------------------------------|
Ich bin noch am Suchen nach einer Funktion die es mir erlaubt die Werte sinnvoll zu Runden und zu Formatieren.
Und eigentlich wollte ich ja nur mehr c++ lernen, und dabei nicht irgendwelche komplett sinnfreien Programme nach dem Schema Eingabe --> if Konstrukt --> Ausgabe produzieren.
SCNR
Ciao, Tobias
On Wed, Jan 16, 2002 at 01:51:13PM +0100, Steffen Liebergeld wrote:
Ausgabe der letzten Version: ~ > meminfo a |#########-------------------------------------------------------------------| Hauptspeicher: 511.539 MB (100%)
... find' ich gut :) Auch wenn ich "meminfo -a" machen würde.
Ich bin noch am Suchen nach einer Funktion die es mir erlaubt die Werte sinnvoll zu Runden und zu Formatieren.
#include <iomanip>
z.B.
cout.setf(cout.fixed); // cout.setf(ios::fixed); cout << setprecision(2);
// cout << fixed << setprecision(2) .... geht leider mit meiner // Library nicht.
cout << ........
Heiko
Am Mittwoch, dem 16. Januar 2002 um 15:51:17, schrieb Heiko Schlittermann:
// cout << fixed << setprecision(2) .... geht leider mit meiner // Library nicht.
std::cout << std::setiosflags(std::ios::fixed);
ist die korrekte Syntax.
Torsten
Mir ist heute ein C++-Problem über den Weg, für das ich mal besonders Tobias' Hilfe in Anspruch nehmen möchte. ;-)
Folgendes Codeschnipsel erzeugt eine Liste aus ca. 1000 pseudozufälligen double-Werten:
srand48(123456789); typedef list<double> list; list l; while (drand48() > 0.001) { l.push_back(drand48()); }
Nun sollen Elemente dieser Liste in mehreren Durchläufen entfernt werden. Pro Durchlauf werden ca. 10 % pseudozufällig entfernt und die Durchläufe werden solange wiederholt, bis die Liste leer ist. Ein korrektes und effizientes Codeschnipsel sieht umständlich aus:
while (!l.empty()) { typedef list::iterator iterator; for (iterator i = l.begin(); i != l.end(); ) { if (drand48() < 0.1) { iterator j = i; i++; l.erase(j); if (l.empty()) { break; } } else { i++; } } }
Die Frage ist, bekomme ich das auch kürzer hin? Effizient und korrekt muss es aber sein.
Torsten
On Wed, Jan 16, 2002 at 04:29:14PM +0100, Torsten Werner wrote:
while (!l.empty()) { typedef list::iterator iterator; for (iterator i = l.begin(); i != l.end(); ) { if (drand48() < 0.1) { iterator j = i; i++; l.erase(j);
Das kannst du abkuerzen zu i = l.erase(i); list::erase() liefert den Zeiger auf das naechste Element zurueck. Das i++ kann man dann entsprechend in die for-Deklaration mit reinnehmen (Mal ganz abgesehen davon, dass dein Algorithmus jedes Element in der Liste loescht, weil er in der for-Schleife nicht hochzaehlt :)).
if (l.empty()) { break; } } else { i++; } }}
Die Frage ist, bekomme ich das auch kürzer hin? Effizient und korrekt muss es aber sein.
Torsten
cu, Ulf
Am Mittwoch, dem 16. Januar 2002 um 19:10:32, schrieb Ulf Lorenz:
Das kannst du abkuerzen zu i = l.erase(i); list::erase() liefert den Zeiger auf das naechste Element zurueck.
Danke, das ist mir neu - sieht aber auch etwas merkwürdig aus.
Das i++ kann man dann entsprechend in die for-Deklaration mit reinnehmen (Mal ganz abgesehen davon, dass dein Algorithmus jedes Element in der Liste loescht, weil er in der for-Schleife nicht hochzaehlt :)).
Doch tut er, hab' ihn schließlich schon benutzt. Übrigens kann man noch einen großen Teil der drand48()-Aufrufe einsparen, woran ich bisher nicht gedacht habe.
Torsten
Am Mittwoch, 16. Januar 2002 15:51 schrieben Sie:
On Wed, Jan 16, 2002 at 01:51:13PM +0100, Steffen Liebergeld wrote:
Ausgabe der letzten Version: ~ > meminfo a
|#########--------------------------------------------------------------- |----|
Hauptspeicher: 511.539 MB (100%)
... find' ich gut :) Auch wenn ich "meminfo -a" machen würde.
Ist implementiert!
Ich bin noch am Suchen nach einer Funktion die es mir erlaubt die Werte sinnvoll zu Runden und zu Formatieren.
#include <iomanip>
z.B.
cout.setf(cout.fixed); // cout.setf(ios::fixed); cout << setprecision(2); // cout << fixed << setprecision(2) .... geht leider mit meiner // Library nicht. cout << ........
Gut, das brauchte ich. Gibt es denn wirklich keine Möglichkeit sowas selber zu finden? Es muss doch eine zentrale Dokumentation geben. Kein Programmierer kann das alles im Kopf haben.
Jetzt habe ich noch eine Frage zur GPL: Wenn ich mein Programm unter die GPL stellen möchte, reicht es dann wenn ich das in den Quelltext oder eine README Datei reinschreibe und die gpl.txt beilege? Kann ich dann immer noch Copyright ... 2002 drunter schreiben oder wiederspricht sich das?
Hallo,
On Wednesday, 16. January 2002 20:10, Steffen Liebergeld wrote: [C++]
Gut, das brauchte ich. Gibt es denn wirklich keine Möglichkeit sowas selber zu finden? Es muss doch eine zentrale Dokumentation geben. Kein Programmierer kann das alles im Kopf haben.
Die beste Dokumentation heißt "Erfahrung". Die zweitbeste sind normalerweise die Header-Dateien, aber gerade bei der STL will man sich das nicht wirklich antun :) Ich schau immer bei oss.sgi.com nach. Ansonsten als Paket: stl-manual - C++-STL documentation in HTML
Jetzt habe ich noch eine Frage zur GPL: Wenn ich mein Programm unter die GPL stellen möchte, reicht es dann wenn ich das in den Quelltext oder eine README Datei reinschreibe und die gpl.txt beilege?
Die beigelegte Datei sollte COPYING heißen, dann weiß jeder gleich was damit anzufangen (und großgeschriebene Dateinamen erscheinen beim Listing normalerweise am Anfang). Empfohlen wird, an den Anfang jeder Quelltextdatei das Template aus der vollständigen GPL (d.h. Lizenz und Nutzungshinweise, letzter Absatz) ausgefüllt zu verwenden. Ich mach das meistens auch, aber das sieht vor allem bei kleineren Sourcen recht dumm aus, da langt mir ein: // Programm Supertoll // Copyright (C) 1999 - 2002 ich, meine@email.adresse // Published under GNU GPL conditions - see file COPYING for details
Manchmal vergißt man das auch... was soll's.
Kann ich dann immer noch Copyright ... 2002 drunter schreiben oder wiederspricht sich das?
Wieso sollte sich das wi(kein e)dersprechen? Die GPL ist eine abschwächende Lizenz, d.h. sie restriktiert nicht, sondern sie erlaubt, ohne deine schriftliche Einwilligung o.ä. (was laut Urheberrecht erforderlich wäre) deine Sourcen zu verändern und unter bestimmten Regeln weiterzuverbreiten.
Natürlich haben wir jetzt erst eine Jahreswende hinter uns, da muß man immer fleißig die Jahreszahl updaten. Wundert mich daß es da noch kein Tool dafür gibt, was das schön konsistent durchführt :)
Josef Spillner
lug-dd@mailman.schlittermann.de
-
Christian Perle -
Heiko Schlittermann -
Josef Spillner -
Steffen Liebergeld -
Tobias Koenig -
Torsten Werner -
Ulf Lorenz