Update Release of STX B+ Tree 0.8.3
Posted on 2008-09-07 18:31 by Timo at Permlink with Comments. Tags: stx-btree b+ tree demo c++ template
Released another updated version 0.8.3 of the STX B+ Tree C++ Template Classes package. The updated release fixes up issues with the root node == NULL when the tree is initially empty.
Fixed crash when running verify() on an empty btree object. Now the root node is freed when the last item is removed. Also fixed crash when attempting to copy an empty btree or when trying to remove a non-existing item from an empty btree.
Also enhancing the speedtest to test the hash table container implementation from __gnu_cxx. Extending tests by another set of runs measuring only the find/lookup functions. See the speed results web page for more information.
The updated source code package is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
C++ Code Snippet - Print Stack Backtrace Programmatically with Demangled Function Names
Posted on 2008-09-01 22:30 by Timo at Permlink with Comments. Tags: c++ code-snippet backtrace
Yesterday I was tasked to analyzed an inner function of a reasonably complex software package. The inner function was called thousands of times from many different parts of the program, a simple counter print-out showed that. However I was interested in which execution paths reach this inner function and how often the different parts access the function.
My straight-forward idea was to dump a stack backtrace each time the inner function is called, similar to the one printed by a debugger. However I needed some code snippet to dump the stack backtrace programmatically, without using gdb to halt the program each time.
Stack backtraces can be saved with backtrace(3), resolved into symbolic names using backtrace_symbols(3) and printed using backtrace_symbols_fd(3). These functions are well documented and fairly easy to use.
However I was debugging a C++ program, which made heavy use of templates and classes. C++ symbols names (including namespace, class and parameters) are mangled by the compiler into plain text symbols: e.g. the function N::A<int>::B::func(int) becomes the symbol _ZN1N1AIiE1B4funcEi. This makes the standard backtrace output very unreadable for C++ programs.
To demangle these strings the GNU libstdc++ library (integrated into the GNU Compiler Collection) provides a function called __cxa_demangle(). Combined with backtrace(3) a pretty stack backtrace can be outputted. The demangling function only works for programs compiled with g++.
The following header file contains a function print_stacktrace(), which uses backtrace(3), backtrace_symbols(3) and __cxa_demangle() to print a readable C++ stack backtrace.
Update Release of STX B+ Tree 0.8.2
Posted on 2008-08-13 16:48 by Timo at Permlink with Comments. Tags: stx-btree b+ tree demo c++ template
Released an updated version 0.8.2 of the STX B+ Tree C++ Template Classes package. The updated release fixes up all issues with iterators and one harmless bad-memory access.
The reverse_iterator classes of the B+ tree were completely reworked. Now they are real implementations and do not use STL magic. Both reverse_iterator and const_reverse_iterator should work as expected now. Added two large test cases for iterators. Enabled public default-constructors on iterators.
Also fixed a memory access bug which happens in erase_one_descend(): leaf->slotkey[leaf->slotuse - 1] if leaf-slotuse == 0. This doesn't have any other bad effect, because the case only occurs when leaf == root and then the resulting btree_update_lastkey message is never really processed. However it still is a bad-memory access.
The updated source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
Published Flex Bison C++ Example 0.1.2
Posted on 2008-08-03 14:26 by Timo at Permlink with Comments. Tags: bison flex c++ code-example
Released an updated source code package for Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This bugfix release solves two problems there were reported to me via e-mail:
The first problem were compilation errors that occured when no %union directive is used in the grammar: in this case the include headers order is changed around by bison and thereby breaks compilation. This was fixed by never including parser.h directly, but always using scanner.h.
And the second issue was raised because new versions of flex were released after years of stagnation. The new flex version 2.5.35 adds a virtual function yywrap() to the yyFlexLexer class. This function is automatically defined in any lexer source file generated by flex. However because I copied FlexLexer.h from an older flex distribution, the function definition throughs a "no yywrap() member function" compiler error. Updating the FlexLexer.h with a conditional declaration of yywrap() hopefully did the trick and now works on all versions. Usually this file should be taken from /usr/include and not from the package. However that will break compilation if flex is not installed, and a self-sufficient compilation package was a primary goal of the example.
For more information and the download package see the Flex Bison C++ Example web page.
Bugfix Release of STX B+ Tree 0.8.1
Posted on 2008-01-25 15:48 by Timo at Permlink with Comments. Tags: stx-btree b+ tree demo c++ template
Released a bugfix version 0.8.1 of the STX B+ Tree C++ Template Classes package. The bug fixed is a possibly illegal memory access during find() function.
I received a new test case via email in which valgrind detected an uninitialized memory access. By tracing it, I soon found that it happens during any find(key) call with a key that is larger than any item contained in the tree. During the find() function find_lower() is called on a leaf node and returns the slot number with the smallest or equal key. However if the queried key is larger than all keys in a leaf node or in the whole tree, find_lower() returns a slot number past the last valid key slot. Comparison of this invalid slot with the queried key then yields an uninitialized memory error in valgrind.
The updated source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
Published Flex Bison C++ Example 0.1
Posted on 2007-08-20 11:53 by Timo at Permlink with Comments. Tags: bison flex c++ code-example
Released example source code package Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This example shows how to use both Flex and Bison in C++ mode. This way both lexer and parser code and data is encapsulated into classes. Thus the lexer and parser are fully re-entrant, because all state variables are contained in the class objects. Furthermore multiple different lexer-parser pairs can easily be linked into one binary, because they have different class names and/or are located in a different namespace.
Why Use These Old Tools? Well, they are here to stay and they work well. But most important, the code generated by Flex and Bison requires no compile-time dependencies, because they generate fully autonomous source code. So far I have not found any modern parser generator which outputs independent code. It is even possible to compile the generated source on Windows with Visual C++ 2005.
For more information and the download package see the Flex Bison C++ Example web page.
Published STX Expression Parser Framework Version 0.7
Posted on 2007-07-17 17:10 by Timo at Permlink with Comments. Tags: stx-exparser c++ library
Released the first version 0.7 of the STX Expression Parser C++ Framework package. The library is licensed under the GNU Lesser General Public License (LGPL) (2.1 or later).
The STX Expression Parser provides a C++ framework, which can process user-specified expression strings containing program-specific variables. It can be integrated into applications to allow user-customized data selection and filtering. The expresssion strings are intuitive SQL-like WHERE-clauses and can contain arbitrarily complex arithmetic. At the same time the expression processing time is guaranteed to be fast enough to safely iterate over larger data sets.
The expression parser can process arbitrarily complex arithmetic expressions like those seen below. To access application-defined data, functions and variables may be included in the expression. An expression can be used as a boolean filter by using comparison and logic operators.
6 + 3 * 12(a - 28) * (int)(e + 0.4 * 2.5 / (PI() - EXP(-0.644) * 4))6 * 9 == 42a >= 5 OR (42 <= field2 AND field2 <= 48) || NOT(got == "yes")
For more information see the STX Expression Parser web page.
Most impressive are the interactive online CGI parser demo and the online CSV file filter.
C++ Code Snippet - In-Place and String-Copy Uppercase/Lowercase Conversion of STL Strings
Posted on 2007-06-02 13:22 by Timo at Permlink with Comments. Tags: std::string c++ code-snippet
This post completes the small C++ function collection of simple STL string manipulations. The following code snippet shows simple locale-unware uppercase and lowercase conversion functions using tolower and toupper. Nothing revolutionary; I'm just misusing this weblog as a code-paste dump for reuseable code.
Sometimes it is better to have a case-insensitive string class. More about ci_string can be found at Guru of the Week (GotW) #29: Case-Insensitive Strings.
#include <cctype>
// functionals for std::transform with correct signature
static inline char string_toupper_functional(char c)
{
return std::toupper(c);
}
static inline char string_tolower_functional(char c)
{
return std::tolower(c);
}
static inline void string_upper_inplace(std::string &str)
{
std::transform(str.begin(), str.end(), str.begin(), string_toupper_functional);
}
static inline void string_lower_inplace(std::string &str)
{
std::transform(str.begin(), str.end(), str.begin(), string_tolower_functional);
}
static inline std::string string_upper(const std::string &str)
{
std::string strcopy(str.size(), 0);
std::transform(str.begin(), str.end(), strcopy.begin(), string_toupper_functional);
return strcopy;
}
static inline std::string string_lower(const std::string &str)
{
std::string strcopy(str.size(), 0);
std::transform(str.begin(), str.end(), strcopy.begin(), string_tolower_functional);
return strcopy;
}
C++ Code Snippet - In-Place and String-Copy Space Trimming of STL Strings
Posted on 2007-05-30 17:28 by Timo at Permlink with Comments. Tags: std::string c++ code-snippet
Yesterday I once again stumbled upon whitespace trimming of STL strings: a check was required if the given user input is empty. Where "empty" also means some user-given string containing only spaces. After one hour of unproductive searching for something as simple as a space trimming function, I decided to put the resulting code here for future reference.
The following code snippet contains two versions of the function: in-place trimming and string-copy trimming. I prefer the copy-trimming function because they allow a more functional programming style. The functions only trim spaces, but can be modified by replacing each ' ' with something like " \n\r\t".
static inline void string_trim_left_inplace(std::string &str)
{
str.erase(0, str.find_first_not_of(' '));
}
static inline void string_trim_right_inplace(std::string &str)
{
str.erase(str.find_last_not_of(' ') + 1, std::string::npos);
}
static inline std::string string_trim_left(const std::string &str)
{
std::string::size_type pos = str.find_first_not_of(' ');
if (pos == std::string::npos) return std::string();
return str.substr(pos, std::string::npos);
}
static inline std::string string_trim_right(const std::string &str)
{
std::string::size_type pos = str.find_last_not_of(' ');
if (pos == std::string::npos) return std::string();
return str.substr(0, pos + 1);
}
static inline std::string string_trim(const std::string& str)
{
std::string::size_type pos1 = str.find_first_not_of(' ');
if (pos1 == std::string::npos) return std::string();
std::string::size_type pos2 = str.find_last_not_of(' ');
if (pos2 == std::string::npos) return std::string();
return str.substr(pos1 == std::string::npos ? 0 : pos1,
pos2 == std::string::npos ? (str.length() - 1) : (pos2 - pos1 + 1));
}
static inline void string_trim_inplace(std::string& str)
{
std::string::size_type pos = str.find_last_not_of(' ');
if(pos != std::string::npos) {
str.erase(pos + 1);
pos = str.find_first_not_of(' ');
if(pos != std::string::npos) str.erase(0, pos);
}
else
str.erase(str.begin(), str.end());
}
Updated STX B+ Tree to 0.8 which now includes wxBTreeDemo
Posted on 2007-05-13 19:48 by Timo at Permlink with Comments. Tags: stx-btree b+ tree demo c++ template
Released an updated version 0.8 of the STX B+ Tree C++ Template Classes package. The update fixes a few segmentation faults with empty trees without root node.
This new release includes the demonstration program wxBTreeDemo. This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes. It allows the user to selected different types of B+ tree instantiations: integer or string keys and different slot numbers. The user may insert and erase key/data pairs from the tree and run different search operations. The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows and MacOSX.
The source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the only slightly changed main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
Published STX B+ Tree C++ Template Classes Version 0.7
Posted on 2007-04-27 15:02 by Timo at Permlink with Comments. Tags: stx-btree b+ tree c++ template
Released the first version 0.7 of the STX B+ Tree C++ Template Classes package. The template classes are licensed under the LGPL.
The STX B+ Tree package is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree. The tree algorithms are based on the implementation in Cormen, Leiserson and Rivest's Introduction into Algorithms, Jan Jannink's paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementation's correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
The source code package is available for download from this webpage.
The classes are documented extensively using doxygen. The generated HTML documentation can be browsed online or downloaded.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster for trees containing more than 16,000 items.
C++ Code Snippet - Compressing STL Strings with zlib
Posted on 2007-03-28 18:23 by Timo at Permlink with Comments. Tags: std::string zlib compress c++ code-snippet
The zlib library can be found on virtually every computer. It is THE general-purpose lossless patent-free compression library.
This small C++ code snippet features a pair of functions which use this ubiquitous library to compress ordinary STL strings. There are many uses for this code snippet, like compressing string data stored in a database or binary data transfered over a network. Keep in mind that the compressed string data is binary, so the string's c_str() representation must be avoided.
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <zlib.h>
/** Compress a STL string using zlib with given compression level and return
* the binary data. */
std::string compress_string(const std::string& str,
int compressionlevel = Z_BEST_COMPRESSION)
{
z_stream zs; // z_stream is zlib's control structure
memset(&zs, 0, sizeof(zs));
if (deflateInit(&zs, compressionlevel) != Z_OK)
throw(std::runtime_error("deflateInit failed while compressing."));
zs.next_in = (Bytef*)str.data();
zs.avail_in = str.size(); // set the z_stream's input
int ret;
char outbuffer[32768];
std::string outstring;
// retrieve the compressed bytes blockwise
do {
zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
zs.avail_out = sizeof(outbuffer);
ret = deflate(&zs, Z_FINISH);
if (outstring.size() < zs.total_out) {
// append the block to the output string
outstring.append(outbuffer,
zs.total_out - outstring.size());
}
} while (ret == Z_OK);
deflateEnd(&zs);
if (ret != Z_STREAM_END) { // an error occurred that was not EOF
std::ostringstream oss;
oss << "Exception during zlib compression: (" << ret << ") " << zs.msg;
throw(std::runtime_error(oss.str()));
}
return outstring;
}
/** Decompress an STL string using zlib and return the original data. */
std::string decompress_string(const std::string& str)
{
z_stream zs; // z_stream is zlib's control structure
memset(&zs, 0, sizeof(zs));
if (inflateInit(&zs) != Z_OK)
throw(std::runtime_error("inflateInit failed while decompressing."));
zs.next_in = (Bytef*)str.data();
zs.avail_in = str.size();
int ret;
char outbuffer[32768];
std::string outstring;
// get the decompressed bytes blockwise using repeated calls to inflate
do {
zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
zs.avail_out = sizeof(outbuffer);
ret = inflate(&zs, 0);
if (outstring.size() < zs.total_out) {
outstring.append(outbuffer,
zs.total_out - outstring.size());
}
} while (ret == Z_OK);
inflateEnd(&zs);
if (ret != Z_STREAM_END) { // an error occurred that was not EOF
std::ostringstream oss;
oss << "Exception during zlib decompression: (" << ret << ") "
<< zs.msg;
throw(std::runtime_error(oss.str()));
}
return outstring;
}
/** Small dumb tool (de)compressing cin to cout. It holds all input in memory,
* so don't use it for huge files. */
int main(int argc, char* argv[])
{
std::string allinput;
while (std::cin.good()) // read all input from cin
{
char inbuffer[32768];
std::cin.read(inbuffer, sizeof(inbuffer));
allinput.append(inbuffer, std::cin.gcount());
}
if (argc >= 2 && strcmp(argv[1], "-d") == 0)
{
std::string cstr = decompress_string( allinput );
std::cerr << "Inflated data: "
<< allinput.size() << " -> " << cstr.size()
<< " (" << std::setprecision(1) << std::fixed
<< ( ((float)cstr.size() / (float)allinput.size() - 1.0) * 100.0 )
<< "% increase).\n";
std::cout << cstr;
}
else
{
std::string cstr = compress_string( allinput );
std::cerr << "Deflated data: "
<< allinput.size() << " -> " << cstr.size()
<< " (" << std::setprecision(1) << std::fixed
<< ( (1.0 - (float)cstr.size() / (float)allinput.size()) * 100.0)
<< "% saved).\n";
std::cout << cstr;
}
}
C++ Code Snippet - Using the Boost.Regex Library
Posted on 2007-03-14 14:43 by Timo at Permlink with Comments. Tags: boost regex c++ code-snippet
The Boost library is a collection of very useful C++ (template) libraries. However it's documentation is very complex and using the library straight-forward usually results in g++ scrolling endless pages of template instantiation errors.
This code snippet shows by example how to use the Boost.Regex library. It compiles and executes regular expressions on strings. Some test I ran showed that it is not as fast as pcre, however Boost.Regex it is easier and more elegant to use in C++ programs. The program must be linked with -lboost_regex.
#include <stdlib.h>
#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
int main()
{
// This regex is compiled at start-up and matches YYYY-MM-DD dates. If it
// contains a syntax error, the program aborts at start-up with an
// exception.
static const boost::regex
date_regex("(199[0-9]|200[0-9])-([1-9]|0[1-9]|1[012])-([1-9]|[0-2][1-9]|3[01])");
// First example: char* c-style input strings use boost::cmatch results.
{
const char *input_cstr = "2007-03-14";
boost::cmatch char_matches;
if (boost::regex_match(input_cstr, char_matches, date_regex))
{
// Convert the parsed number using boost's lexical_cast library
int year = boost::lexical_cast<int>( char_matches[1] );
// Or use the old way: get the std::string object, then it's char*
int month = atoi( char_matches[2].str().c_str() );
std::cout << "First example:"
<< " year " << year
<< " month " << month
<< " day " << char_matches[3] << "\n";
}
else
{
std::cout << "First example should have matched the regex.\n";
}
}
// Second example: STL strings use boost::smatch results.
{
std::string input_stlstr = "2007-03-34";
boost::smatch str_matches;
if (boost::regex_match(input_stlstr, str_matches, date_regex))
{
std::cout << "Second example shouldn't have matched the regex.\n";
}
else
{
std::cout << "Second example didn't match the regex. This was intended.\n";
}
}
// Third example: Temporary regex object and no capture results needed.
{
if (boost::regex_match("2007", boost::regex("(199[0-9]|200[0-9])")))
{
std::cout << "Third example matched the temporary regex object.\n";
}
else
{
std::cout << "Third example should have matched the regex.\n";
}
}
// Fourth example: regex_match matches the whole string while regex_search
// matches substrings just like perl.
{
std::string input = "Today is 2007-03-14, how are you?";
if (boost::regex_match(input, date_regex))
{
std::cout << "Fourth example (regex_match) shouldn't match.\n";
}
else
{
std::cout << "As expected, the fourth example (regex_match) didn't match.\n";
}
if (boost::regex_search(input, date_regex))
{
std::cout << "While the fourth example using regex_search did matched.\n";
}
else
{
std::cout << "Fourth example using regex_search should have matched the regex.\n";
}
}
}
C++ Code Snippet - Making a Custom Class ostream Outputable
Posted on 2007-03-01 14:47 by Timo at Permlink with Comments. Tags: std::string std::ostream printable c++ code-snippet
How to get a custom class to work with std::cout << obj; ? I for my part always forget the exact prototype of the required operator<<. Here is an minimal working example to copy code from:
struct myclass
{
int a, b;
myclass(int _a, int _b)
: a(_a), b(_b)
{ }
};
// make myclass ostream outputtable
std::ostream& operator<< (std::ostream &stream, const myclass &obj)
{
return stream << "(" << obj.a << "," << obj.b << ")";
}
int main()
{
myclass obj(42, 46);
std::cout << obj << std::endl;
}
QtSqlView 0.8.0 Released
Posted on 2006-10-10 12:56 by Timo at Permlink with Comments. Tags: qtsqlview c++
Released the first version 0.8.0 of QtSqlView under the GPL.
QtSqlView is a simple and easy to use SQL database browser written in Qt 4.x using the excellent QtSql components. Using QtSql drivers it can natively connect to MySQL, PostgreSQL and SQLite databases. Furthermore other database systems may be accessed using their ODBC drivers. QtSqlView is released under the GNU General Public License: source code and win32 binary may be downloaded here.
This short program was initially written for a set of windows users, who need to access and edit a PostgreSQL database. All this is possible with M$ Access and ODBC, but the configuration of PostgreSQL's ODBC driver and the ODBC DSN is far too complicated for the average database editor. Thus problem-free access of open-source databases was top priority for QtSqlView.
QtSqlView boasts the following features:
- Problem-free connecting to MySQL, PostgreSQL and SQLite databases on Windows.
- Add, delete and modify a list of database connections.
- Browse, edit, save and revert SQL tables, system tables and views of registered connections
- Copy selected cells as tab-separated text to the clipboard.
- View table schema including primary key.
- Execute custom SQL queries on the database connect and view results.
- SQL syntax highlighting in query editor.
- Uses Qt4's greatly improved SQL components.
You may download the source code for Linux/OSX or a setup package for Windows.
More screenshots are available as well.
sdlfractal 0.1
Posted on 2006-08-09 21:33 by Timo at Permlink with Comments. Tags: sdlfractal sdl c++
Sdlfractal is a port of a simple little fractal generator which I wrote some five years ago. It is not supposed to replace wonderful tools like xfractint so it is very simple and not very fast. The main goal of this project was to learn SDL and it turned out that fltk was also required. The main construction is an SDL surface extended by a canvas class which simulates a high-resolution coordinate system. On this coordinate system the fractals can be drawn.
To control fractal parameters the generator displays a second window using the fltk engine. From this dialog the currently displayed fractal and it's parameters can be changed. This requires a dual engine event loop in the program.
By dragging the mouse on the drawing canvas you can zoom into all fractals. If fractal drawing takes too long (and nothing is shown), then just click the canvas and the generator will stop.
The fractal generator can also save high-resolution PNG files. The following images are some examples created by the fractal generator.
The source code to sdlfractal 0.1 can be downloaded in a tar.bz2 archive (121 KB). It is also browsable on the web.
Sdlfractal was designed to the portable to Win32 using SDL and fltk compiled with MinGW. A compiled version which should run out of the box on most windows. Download the zip archive (267 KB) containing the executable.
MD5sums of the source and binary archives:
538da60a5ef2d427fbb901d6080e631e sdlfractal-0.1.tar.bz2
5bab1ccb93e170f5c42d995a6761ca7a sdlfractal-0.1-win32.zip
 | This section of the mandelbrot fractal is so beautiful that it is my current wallpaper. It can be downloaded at 800x600 (242 KB), 1024x768 (372 KB) or 1280x960 (552 KB). |
Vortrag "Objekt-orientiertes Programmieren in C"
Posted on 2006-05-03 16:19 by Timo at Permlink with Comments. Tags: university talk c++
Im Sommersemester 2005 habe ich am Praktikum "Real-Life Programming" am IPD Lehrstuhl der UniKa teilgenommen. Hier platt die Beschreibung von der Homepage zitiert:
Wie programmiert man richtig?
Viele performancekritische Software wird immer noch in C geschrieben. C erlaubt dem Compiler einen sehr großen Optimierungsspielraum, in diesem Praktikum wird geübt, wie dieser ausgenutzt werden kann und wie die dabei auftretenden Klippen zu umschiffen sind.
In diesem Kontext könnt ihr lernen:
- Den Umgang mit den UNIX Entwicklungswerkzeugen
- Schreiben von portablem Code
- Verständnis des Übersetzungsprozesses von C
- Analysieren des durch Übersetzer erzeugten Assemblertextes
- Programmieren, so dass der Übersetzer guten Code erzeugen kann
- Wie man die Performance von Programmen steigern kann
- Umgang mit großen Projekten
- Das Finden von Fehlern in großen und alten Softwaresystemen
- Beherrschen von Debugging und Profiling Werkzeugen
- Kniffe des C-Präprozessors
- Die "Geheimnisse" von C
In diesem Zusammenhang haben zwei Komilitonen und ich einen Vortrag über "Objekt-orientiertes Programmieren in C" (ohne ++) ausgearbeitet und gehalten. Weiteres Schwerpunktthema war die Darstellung von C++ in Maschine, also wie der C++ Übersetzer dann die Klassen abbildet.
| Vortragsfolien: | OOC-Folien.pdf | 179 kB |
| Handout: | OOC-Handout.pdf | 122 kB |
| Beispielcode: | OOC-Beispiele.tar.gz | 4 kB |
Hier noch ein Auszug des Inhaltsverzeichnisses:
- Objekt-Orientierte Konzepte
- OO in C
- Kapselung und Geheimnisprinzip
- Vererbung und Polymorphie
- Generiztiät
- Darstellung von C++ in Maschine
- vtable
- Name-Mangling
- Run-Time-Type Information (RTTI)
Diese Folien geben einen kompetenten Überblick über den Themenbereich.
