Shashin Error:

Invalid data property __get for imageDisplay
Zum Inhalt springen

Archiv

Kategorie: Coding

Obwohl es Exceptions im C++ Standard schon etliche Jahre gibt, werden diese in größeren Projekten oft nicht eingesetzt. Im folgenden Artikel möchte ich das Für und Wider erörtern und mit gängigen Vorurteilen aufräumen.

try {
    funktion();
   ...
} catch (const std::invalid_argument& e) {
    std::cerr < < "Falsches Argument:"  << e.what() << std::endl;
} catch (const std::range_error& e) {
    std::cerr << "Ungültiger Bereich:" << e.what() << std::endl;
} catch (...) {
    std::cerr << "Sonstiger Fehler" << std::endl;
}

Gängige Vorurteile

  1. Die Behandlung von Ausnahmen ist codeintensiver (mehr Schreibarbeit)
    Falsch. Ein sinnvolles try/catch braucht ist sogar weniger Code als ein sinnvolles if/else if/elsefür alle möglichen Fehlercodes. Fehlercodes werden aber oft nicht vollständig überprüft oder gar ganz weggelassen, was der Qualität des Codes nicht gerade zuträglich ist. Exceptions dagegen zwingen zu einer durchdachten Fehlerbehandlung.
  2. Exceptions machen den Code langsam
    Falsch. Wenn Exceptions richtig eingesetzt werden, sollten sie für Ausnahmen im Programmablauf verwendet werden. Die Ausführungsgeschwindigkeit des „Gut“-Pfades (in dem keine Ausnahmen geworfen werden) leidet nicht darunter. Wenn also die Exception die Ausnahme und nicht die Regel ist, hat man nichts zu befürchten. weiter lesen…
#pragma comment( lib, "version" )
struct FileVersion
{
	DWORD dwLeftMost;
	DWORD dwSecondLeft;
	DWORD dwSecondRight;
	DWORD dwRightMost;
	bool IsLower( const FileVersion&amp; ver )
	{
		return dwLeftMost &lt; ver.dwLeftMost ? true :
			dwSecondLeft &lt; ver.dwSecondLeft ? true :
			dwSecondRight &lt; ver.dwSecondRight ? true :
			dwRightMost &lt; ver.dwRightMost ? true : false;
	}
};
 
static void GetFileVersion( const CString&amp; fileNameWithPath, FileVersion&amp; fileVersion )
{
	DWORD dwDummy;
	DWORD dwFVISize = GetFileVersionInfoSize( fileNameWithPath , &amp;dwDummy );
	LPBYTE lpVersionInfo = new BYTE[dwFVISize];
	::GetFileVersionInfo( fileNameWithPath , 0 , dwFVISize , lpVersionInfo );
	UINT uLen;
	VS_FIXEDFILEINFO* lpFfi;
	::VerQueryValue( lpVersionInfo , _T("\\") , (LPVOID *)&amp;lpFfi , &amp;uLen );
	DWORD dwFileVersionMS = lpFfi-&gt;dwFileVersionMS;
	DWORD dwFileVersionLS = lpFfi-&gt;dwFileVersionLS;
	delete[] lpVersionInfo;
	fileVersion.dwLeftMost = HIWORD(dwFileVersionMS);
	fileVersion.dwSecondLeft = LOWORD(dwFileVersionMS);
	fileVersion.dwSecondRight = HIWORD(dwFileVersionLS);
	fileVersion.dwRightMost = LOWORD(dwFileVersionLS);
}

Ok, ich wollte nur mal eben bei meinem Projekt eine Klasse in ein XML dumpen und wieder einlesen. Hab ich ja mit boost::serialization schon öfter gemacht. Leider hab ich die Klasse aber unter Qt entworfen und daher Basistypen wie QString verwendet. Dieser hat sich allerdings zunächst geweigert…
weiter lesen…

Mit dem C++ Schlüsselwort „explicit“ kann man dem Compiler implizite Typumwandlungen verbieten. Dies kann manchmal ja auch ungewollt passieren, wie folgendes Beispiel zeigt:

#include <iostream>
#include <windows.h>
struct MyClass
{
    MyClass(const char* name) : m_Name(name) {}
    virtual ~MyClass() {}
    const char* Who() const { return m_Name; }
private:
    const char* m_Name;
};
 
struct MyExplicitClass
{
    explicit MyExplicitClass(const char* name) : m_Name(name) {}
    virtual ~MyExplicitClass() {}
 
    const char* Who() const { return m_Name; }
private:
    const char* m_Name;
};
 
 
int main()
{
    MyClass A("a");
    MyExplicitClass B("b");
 
    A = "c";  // ok, hier funktioniert das, aber war das auch so gewollt? 
              // Auf den ersten Blick zu durchschauen ist diese Zuweisung jedenfalls nicht.
 
    B = "d";  // error C2679: Binärer Operator '=': Es konnte kein Operator gefunden werden, 
              // der einen rechtsseitigen Operanden vom Typ 'const char [2]' akzeptiert (oder
              // keine geeignete Konvertierung möglich)
 
    std::cout << "A: " << A.Who() << std::endl;
    std::cout << "B: " << B.Who() << std::endl;
 
    return 0;
}

Multi-Zwischenablage

Eher zufällig bin ich beim Coden auf ein nettes Feature im Visual Studio (2008) gestoßen: VS hat eine mehrfache Zwischenablage auf die man mittels Shift+Ctrl+V zugreifen kann. Somit kann man auch auf Sachen zugreifen, die man eigentlich schon überschrieben hat.
vs2008_clipboard

Inkrementelle Datei-Suche

Mittels Ctrl+# gelangt man in das Suchen-Feld. Dort kann man mittels <of + Dateiname Dateien öffnen. Dabei werden alle Dateien der Solution inkrementell auf die Eingabe gematcht und in einer Combobox angeboten.

EIS

Easy Installation System


Mein Installations-Tool, das Easy Installation System, ist jetzt auf Google Code verfügbar. EIS ist ein vollständiges Installationssystem, das in MASM32 geschrieben wurde. Es ist in deutsch und englisch verfügbar und für RAR-Dateien ausgelegt. Weitere Details auf der Projektseite: http://code.google.com/p/eis/

Die Entscheidung es OpenSource zu machen fiel, da ich leider nicht mehr genug Zeit habe es zu pflegen. Ich fände es allerdings schade, wenn das Projekt einfach so in der Versenke verschwinden würde.

Ich werde zwar versuchen, das Projekt weiter zu verwalten, aber viel Zeit kann und will ich dafür nicht mehr investieren.

Eine abstrakte Klasse in C++ hat mindestens eine pure virtual Funktion (gekennzeichnet durch virtual ... = 0). Diese Funktionen können per Definition nicht direkt aufgerufen werden, da sie keine Implementierung haben (auch per Definition). Sollte die Methode dennoch aufgerufen werden, wird das Programm (von der Runtime) mit der Fehlermeldung „Pure virtual function call“ abgebrochen. weiter lesen…

Bisher habe ich Programme immer in MASM32 geschrieben, wenn es darum ging, möglichst effiziente und platzsparende Executables zu erzeugen. Mann kann aber auch prima mit nativem C oder C++ die Dateigröße drastisch reduzieren. weiter lesen…

#include <iostream>
 
using namespace std;
 
int main()
{
   cout << "Hi, freaky world!" << endl;
   return 0;
}

GPGPU

Jul 4

GPGPU means General Purpose computation on Graphics Processing Units. On this page a few basic programs and libraries are presented that show how the GPU can be used for computer vision tasks like edge detection.

Requirements

The following hardware and software is needed to run the programs:

  • A graphics card (and driver) that supports OpenGL 2.0
  • The OpenGL Utility Toolkit (GLUT)
  • C for Graphics (Cg)
  • C++ (e.g. Visual C++ 8.0)

  GLUT Win32 3.7.6 (117,1 KiB, 1.137 hits)
This is GLUT for Win32 version 3.7.6 as of Nov 8th 2001 by Nate Robins.

  Simple Shader Test (194,2 KiB, 1.329 hits)
Simple demo program that demonstrates the use of Cg shaders for GPGPU using some edge detection filters (Sobel, Laplacian, Laplacian of Gaussian, Difference of Gaussian). Program needs glut32.dll Cg.dll and CgGL.dll. shadertest

Links