  |
|
 Thema: C++ Probleme mit set_new_handler |
|
|
Aus 'Effective C++' von Scott Meyers:
| Zitat: |
To specify the out-of-memory-handling function, clients call set_new_handler, which is specified in the header
<new> more or less like this:
typedef void (*new_handler)();
new_handler set_new_handler(new_handler p) throw();
As you can see, new_handler is a typedef for a pointer to a function that takes and returns nothing, and
set_new_handler is a function that takes and returns a new_handler.
set_new_handler's parameter is a pointer to the function operator new should call if it can't allocate the
requested memory. The return value of set_new_handler is a pointer to the function in effect for that purpose
before set_new_handler was called.
You use set_new_handler like this:
// function to call if operator new can't allocate enough memory
void noMoreMemory()
{
cerr << "Unable to satisfy request for memory\n";
abort();
}
int main()
{
set_new_handler(noMoreMemory);
int *pBigDataArray = new int[100000000];
...
}
If, as seems likely, operator new is unable to allocate space for 100,000,000 integers, noMoreMemory will be
called, and the program will abort after issuing an error message. This is a marginally better way to terminate the
program than a simple core dump. (By the way, consider what happens if memory must be dynamically allocated
during the course of writing the error message to cerr...)
When operator new cannot satisfy a request for memory, it calls the new-handler function not once, but repeatedly
until it can find enough memory. The code giving rise to these repeated calls is shown in Item 8, but this high-level
description is enough to conclude that a well-designed new-handler function must do one of
the following:
-- Make more memory available. This may allow operator new's next attempt to allocate the memory to
succeed. One way to implement this strategy is to allocate a large block of memory at program start-up, then
release it the first time the new-handler is invoked. Such a release is often accompanied by some kind of
warning to the user that memory is low and that future requests may fail unless more memory is somehow
made available.
-- Install a different new-handler. If the current new-handler can't make any more memory available, perhaps it
knows of a different new-handler that is more resourceful. If so, the current new-handler can install the other
new-handler in its place (by calling set_new_handler). The next time operator new calls the new-
handler function, it will get the one most recently installed. (A variation on this theme is for a new-handler to
modify its own behavior, so the next time it's invoked, it does something different. One way to achieve this is
to have the new-handler modify static or global data that affects the new-handler's behavior.)
-- Deinstall the new-handler, i.e., pass the null pointer to set_new_handler. With no new-handler installed,
operator new will throw an exception of type std::bad_alloc when its attempt to allocate memory is
unsuccessful.
-- Throw an exception of type std::bad_alloc or some type derived from std::bad_alloc. Such
exceptions will not be caught by operator new, so they will propagate to the site originating the request for
memory. (Throwing an exception of a different type will violate operator new's exception specification.
The default action when that happens is to call abort, so if your new-handler is going to throw an exception,
you definitely want to make sure it's from the std::bad_alloc hierarchy. For more information on
exception specifications, see Item M14.)
-- Not return, typically by calling abort or exit, both of which are found in the standard C library (and thus
in the standard C++ library — see Item 49).
These choices give you considerable flexibility in implementing new-handler functions.
|
Da steht erstmal alles noetige, was man wissen muss, um set_new_handler() zu benutzen, speziell dass es eine void-Funktion sein muss, und dass man dem Handler einen Zeiger auf diese Funktion uebergeben muss.
Fuer weiters kann ich dir das Buch von Scott Meyers waermstens empfehlen, da steht alles wichtige in Sachen C++-Grundlagen drin.
|
|
| Thema: Provider Eure Internetanbindungen |
|
|
Naja zumindest bei dem ersten ist der Ping nicht ganz richtig, so schlecht sind wir hier nicht.
Kanns leider auch nicht direkt testen, muss hier durch einen Proxy-Server vom Institut oder vom ReZe durch.
|
|
| Thema: Provider Eure Internetanbindungen |
|
|
Habs natuerlich wieder verpeilt daran zu denken.
Aber morgen bestimmt.
Aber die RWTH Aachen kann ja nur eine bessere Anbindung haben, als irgendeine Universitaet in Stuttgart 
|
|
| Thema: Provider Eure Internetanbindungen |
|
|
Dann ist mein Ping im Vergleich doch nicht so schlecht, wie ich dachte....
Wollte gerade einen Thread oeffnen und nach euren Pings fragen.
Morgen teste ich dann mal aus dem Institut, mal schauen, was der DFN-Backbone hinkriegt...
Dann mach ich euch alle nass
(hoffe ich mal)
|
|
| Thema: C++ Variablenwert als Char in Datei schreiben |
|
|
Ich habe deine Frage auch nicht richtig verstanden, interpretiere sie aber auch anders als phlox81.
Der Unterschied zwischen << "\n" und << std::endl ist, dass std::endl auch noch ein flush() ausfuehrt, wodurch gepufferte daten auf den stream geschrieben werden.
Probier mal
| code: |
1:
|
std::cout << (char)i << std::flush; |
|
|
|
| Thema: C++ Variablenwert als Char in Datei schreiben |
|
|
Abgesehen davon, dass ich nicht verstanden habe, wie dein Programm sich die Eingabe besorgt (was hier aber ja egal zu sein scheint), wirst du bei jedem oeffnen der Datei "log.txt" eine neue Datei anlegen und die alte ueberschreiben.
Ist dein Problem, dass die Datei nachher nur einen Eintrag enthaelt oder steht garnichts drin?
Wenn du anhaengen willst, musst du die Datei mit dem Flag std::ios::app oeffnen [1]
Ausserdem waere es sinnvoll die Datei fuer die Laufzeit des Programms offen zu halten, da du die Datei sonst vollkommen unnoetigerweise bei jedem Tastendruck (oder loslassen) erneut oeffnest.
[1] http://www.cplusplus.com/reference/iostr...m/ofstream.html
|
|
| Thema: C++ Dezimalwert von Zeichen rausfinden |
|
|
Du musst die chars gar nicht umwandeln, um damit zu rechnen.
| code: |
1:
2:
3:
4:
5:
|
char a = 'a';
a += 3;
std::cout << a << std::endl;
|
|
sollte ohne weiteres funktionieren. Intern verarbeitet der char wie integer-Variablen.
|
|
| Thema: Physik Physik Aufgaben von Exe`s Freundin |
|
|
| Zitat: |
Original von grandmaster S
Ich frag mich die ganze Zeit, ob die Federkonstante gar keine Rolle spielt? Die ist ja nicht angegeben. Bei der Energieerhaltung spielt ja auch die Feder keine ernstzunehmende Rolle. Die Glleichung würde ja dann auch nur mit Pendel gelöst werden können. Oder seh ich das da irgendwie falsch? |
Ja. Man soll ja nur eine Gleichung fuer die Geschwindigkeit, abhaengig von der Auslenkung angeben und keinen Zahlenwert.
Und natuerlich spielt die Federkonstannte eine Rolle. Die Energie, die man in System steckt ist ja dann groesser, wenn man die Kugel auslenkt.
|
|
| Thema: Physik Physik Aufgaben von Exe`s Freundin |
|
|
Jo und eigentlich sollte q wohl ein \theta sein, aber da mir q zu bloede war habe ich den Winkel kurzerhand \phi genannt.
Banur:
Der Ansatz mit der Energieerhaltung koennte vielversprechender sein, als der mit der Bewegungsgleichung.
E_{pot} + E_{pot,Feder} bei maximaler Auslenkung = E_{kin} im Nulldurchgang.
Wenn mans ueber Newton rechnet wirds echt dreckig.
|
|
| Thema: Physik Physik Aufgaben von Exe`s Freundin |
|
|
Deine Freundin soll mal fragen, ob die Formel auch eine Differentialgleichung sein darf.
Ich hab das Ding jetzt komplett aufgeschrieben, aber es sieht nicht so aus, als liesse sich das ohne weiteres loesen.
Numerisch oder mit anderen Naeherungsmethoden kann man sicher was angeben, aber eine analytische Loesung duerfte schwer zu finden sein (wenn ueberhaupt)
|
|
| Thema: Physik Physik Aufgaben von Exe`s Freundin |
|
|
Ihr versteht das falsch.
Das Pendel wird um einen Winkel \phi_0 ausgelenkt und dann ist die Frage, wie die Geschwindigkeit bei \phi=0 aussieht in Abhaengigkeit der Auslenkung \phi_0
Geht sicher ganz einfach ueber Newton. Wenn ich mich nachher mal langweile, gucke ich mal.
|
|
| Thema: Physik Physik Aufgaben von Exe`s Freundin |
|
|
Misels Loesung ist auf jeden Fall verkehrt.
In die Reibungskraft geht nur die Normalenkomponente ein und ausserdem noch die Geschwindigkeit, wenn ich das noch richtig im Kopf habe
[Edit]
46613.4W =~ 63PS ist richtig.
Die Geschwindigkeit geht nur bei dynamischen Problemen ein.
|
|
| Thema: Java Datei Einlesen, performant? |
|
|
| Zitat: |
Original von phlox81
Gerade bei einer solchen Einleseoperation, sollte der Unterschied nicht allzu groß sein.
|
Gerade dabei ist Java langsam. Jedes eingelesene Ascii-Zeichen muss erst zweimal konvertiert werden. Einmal nach Big Endian und dann nach UTF-8 (oder umgekehrt, keine Ahnung).
Dazu kommt in dem Fall, dass mehr als nur ein paar kilobyte Speicher allokiert werden muessen, was auch unwahrscheinlich viel Zeit kostet unter Java. Wenn haeufig oder wenn viel Speicher allokiert werden muss, ist Java immer noch um einen Faktor 100 bis 1000 langsamer als vergleichbare C/C++ Programme.
Ich habe mal ein kleines c++ Programm geschrieben, dass das gleiche macht.
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
|
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
std::stringstream buffer; //!< string buffer (line by line)
std::vector<char> binBuffer; //!< binary buffer
/*!
* Line-by-line read -- adding to stringbuffer
*/
void bufferedReader( char* fileName )
{
std::ifstream file( fileName );
std::string line;
while ( ! file.eof() )
{
std::getline( file, line );
buffer << line << std::endl;
}
file.close();
}
/*!
* Binary-at-once read -- adding to STL vector
*/
void binReader( char* fileName )
{
std::ifstream binFile( fileName, std::ios::binary | std::ios::in );
binFile.seekg( 0, std::ios::end );
size_t binSize = binFile.tellg();
binFile.seekg( 0, std::ios::beg );
size_t buffPos = binBuffer.size();
binBuffer.resize( buffPos + binSize );
binFile.read( &(binBuffer[buffPos]), binSize );
binFile.close();
}
/*!
* argv[1] -> filename; argv[2] -> "1": stringstream, "2": binary STL vec
*/
int main( int, char** argv )
{
if ( std::string( argv[2] ) == "1" )
{
for ( int i = 0; i < 100; ++i )
{
bufferedReader( argv[1] );
}
std::cout << "[MAIN] total bytes added to buffer: " << buffer.str().length() << std::endl;
}
else if ( std::string( argv[2] ) == "2" )
{
for ( int i = 0; i < 100; ++i )
{
binReader( argv[1] );
}
std::cout << "[MAIN] total bytes added to buffer: " << binBuffer.size() << std::endl;
}
return 0;
} |
|
Wie man sieht, muss ich die Einleseoperationen wenigsten 100 mal ausfuehren, damit ich sinnvoll eine Zeit messen kann.
Die einzulesende Datei ist der Quellcode eines Gittergenerators, die groesste Textdatei, die ich gerade finden konnte:
| code: |
1:
2:
|
$ wc ~/NLD/src/libnldtools/extern/tetgenio/tetgen.cxx
34961 151648 1278017 /home/ulli/NLD/src/libnldtools/extern/tetgenio/tetgen.cxx |
|
Das heisst es werden insgesammt 127801700byte in den Puffer geladen, ohne dass er zwischendurch geleert wird.
Ausserdem habe ich das Programm mit "-O0" kompiliert, damit der Kompiler nicht optimiert und der Code wirklich so ausgefuehrt wird.
Hier die Ergebnisse:
String buffer:
| code: |
1:
2:
3:
4:
5:
6:
|
$ time ./readfile /home/ulli/NLD/src/libnldtools/extern/tetgenio/tetgen.cxx 1
[MAIN] total bytes added to buffer: 127801800
real 0m9.885s
user 0m6.060s
sys 0m1.728s |
|
STL vector / binaer:
| code: |
1:
2:
3:
4:
5:
6:
|
$ time ./readfile /home/ulli/NLD/src/libnldtools/extern/tetgenio/tetgen.cxx 2
[MAIN] total bytes added to buffer: 127801700
real 0m5.802s
user 0m1.803s
sys 0m1.812s |
|
Und das auf einem 800MHz Duron mit 256MB Arbeistspeicher, womit die einzuladenen ~120MB schon weh tun.
Aus eigener Erfahrung weiss ich, dass das unter Java vollkommen anders aussaehe.
Ich habe es jetzt nicht ausprobiert, aber Antiheld hat ja schon bemerkt, dass eine einzige Einleseoperation so lange dauert, wie bei mir 100.
Das soll jetzt auch nicht als Aufruf oder Beitrag zum Flamewar verstanden werden, sondern ist nur eine simple Feststellung.
Wir hatten Antiheld ja bereits geholfen, und zum rumspielen und lernen ist Java ja auch ganz in Ordnung.
|
|
| Thema: Java Datei Einlesen, performant? |
|
|
Willkommen in der Welt von Java 
Ich will jetzt nicht unsachlich staenkern, aber Java und Performance schliessen sich gegenseitig weitestgehend aus.
Ich weiss auch wovon ich rede, wir haben in unserer Gruppe einige Java-Programme laufen und vergleichbarer C/C++ Code ist immer schneller und oftmals viel schneller.
Das Problem in deinem Fall konkret koennte sein, dass der string 40k mal erweitert werden muss, d.h. neuer Speicher allokiert werden muss, ...
Wie das konkret funktioniert kann ich dir nicht sagen, aber es ist nicht ausgeschlossen, dass wirklich bei jedem += neuer Speicher gesucht werden muss, was gerade bei Java ewig dauert.
Vielleicht versuchst du den String vorher auf die Groesse der Datei zu bringen und schreibst dann Zeichen fuer Zeichen in die Elemente des Strings? Der Vorteil waere, dass du nur einmal Speicher allokieren musst.
|
|
| Thema: Festplatte Idee einer nicht mehr wiederherstellbaren Formatierung |
|
|
Sorry Exekutor, aber eure Idee duerfte sehr wirkungslos sein. Einfach nur das Dateinsystem gegen ein verschluesseltes zu tauschen aendert nichts an den alten Daten, die dann noch da liegen. Man muesste tatsaechlich das neue verschluesselte Dateisystem einmal bis zum Rand vollschreiben, um sicherzustellen alle Daten zumindest einmal ueberschrieben zu haben.
Ein vollkommen unnoetiger Aufwand und extrem muehselig, ausserdem wirkungslos, da einmal ueberschriebene Daten durchaus wiederhergestellt werden koennen.
Die Formatierung der Festplatte bringt exakt garnichts, da die Platte vorher bereits auf die gleiche Art und Weise formatiert war. Auch hier geschieht mit den eigentlichen Daten nichts.
Die einzige Loesung ist das geziehlte mehrfache Ueberschreiben mit sowohl Zufallsdaten, als auch Daten, die eine gewisse Struktur aufweisen, sonst kann man die echten Daten genau anhand dieser Struktur erkennen.
Das Unix-Programm shred ueberschreibt in der default-Einstellung die Daten 25 mal mit den verschiedensten Masken. Zum Abschluss kann man optional noch einmal Nullen drueberschreiben lassen, um den Vorgang zu verschleiern.
shred kann man auch direkt auf ganze Laufwerke anwenden und muss nicht einzelne Datein loeschen, was gerade bei Journaling-Dateisystemen problematisch ist.
Bleibt noch Misels Mikrowelle - wobei ich da auch von der Zuverlaessigkeit nicht ueberzeugt bin.
|
|
| Thema: Ubuntu Mountpoint mit Leerzeichen? (War: Superkaramba Theme) |
|
|
Dann liegts an deinem automounter - keine Ahnung welchen deine Distro verwendet.
Ich habe ivman installiert. Durchforste mal /var/log/messages oder /var/log/syslog nach Meldungen deines automounters - koennte etwas muehselig sein.
Bei mir steht da, abgesehen von ein bisschen vorgeplaenkel ueber ein neu erkanntes USB-Geraet sowas:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
|
Dec 11 20:54:23 thor ivman: New Device: /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0
Dec 11 20:54:23 thor ivman: UDI /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0 is device /dev/sdb1
Dec 11 20:54:23 thor ivman: Device /dev/sdb1 appears to be mountable
Dec 11 20:54:23 thor ivman: Giving other programs a chance to mount...
Dec 11 20:54:28 thor ivman: Attempting to mount device /dev/sdb1
Dec 11 20:54:28 thor ivman: Running: pmount -u 007 '/dev/sdb1'
Dec 11 20:54:28 thor FAT: utf8 is not a recommended IO charset for FAT filesystems, filesystem will be case sensitive!
Dec 11 20:54:29 thor ivman: Device /dev/sdb1 is mounted at /mnt/usbstick
Dec 11 20:54:29 thor ivman: UDI /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0 is device /dev/sdb1
Dec 11 20:54:29 thor ivman: Device /dev/sdb1 appears to be mountable
Dec 11 20:54:29 thor ivman: Checking for video DVD in device '/dev/sdb1' mounted at '/mnt/usbstick'
Dec 11 20:54:29 thor ivman: /dev/sdb1 does not look like a video DVD
Dec 11 20:54:29 thor ivman: UDI /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0 is device /dev/sdb1
Dec 11 20:54:29 thor ivman: Device /dev/sdb1 appears to be mountable
Dec 11 20:54:29 thor ivman: Mounted: /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0
Dec 11 20:54:29 thor ivman: Devices table has 2 entries
Dec 11 20:54:29 thor ivman: "/org/freedesktop/Hal/devices/volume_uuid_8093_8F05" "/dev/sda1"
Dec 11 20:54:29 thor ivman: "/org/freedesktop/Hal/devices/volume_uuid_475E_F8E0" "/dev/sdb1"
Dec 11 20:54:29 thor ivman: UDI /org/freedesktop/Hal/devices/volume_uuid_475E_F8E0 is device /dev/sdb1
Dec 11 20:54:29 thor ivman: Device /dev/sdb1 appears to be mountable |
|
Allerdings habe ich auch einen Eintrag fuer /dev/sdb1 in der /etc/fstab.
Ausserdem habe ich ueber udev sichergestellt, dass mein Handy als USB-Stick immer /dev/sdb heisst.
|
|
| Thema: Ubuntu Mountpoint mit Leerzeichen? (War: Superkaramba Theme) |
|
|
Achso, na da kenn ich mich nicht aus, meine Windows-Platten hiessen immer C, D, E, ....
Wenn du nicht rausfindest wer wie das Ding mountet, kannst du dir zwischenzeitlich mit
| code: |
1:
|
mount --bind "/media/RAGGA SKA" /media/NeuerMountPoint |
|
helfen. Vorrausgesetzt, mount --bind stoert sich nicht an dem Leerzeichen
|
|
| Thema: Ubuntu Mountpoint mit Leerzeichen? (War: Superkaramba Theme) |
|
|
Und wie kommt deine Kiste dann auf den Namen "RAGGA SKA" - sowas denkt sich das Ding doch nicht selbst aus.
Du musst irgendwann mal eine udev-rule fuer das Teil definiert haben, vermutlich wirst du in /etc/udev/...... fuendig, aber dazu kann ich dir nu wirklich garnix mehr sagen, da jede Distribution da eigene Spielregeln hat und die meisten haben auch irgendwelche Werkzeuge, um solche Einstellungen vorzunehmen.
Alternative:
und dann einen mountpoint ohne Leerzeichen angeben.
|
|
|
|
