[ Hypercell ein ] [ Hypercell aus ] [ Zeige Navigation ] [ Verstecke Navigation ]
c++.de  
   
Forentreff 2012   [ Startseite ] [ Links ] [ FAQs ] [ Humor ] [ Compiler ] [ Bücher ] [ Magazin ] [ Tutorials ] [ Videos ] [ Impressum & AGB ] [ Twitter Twitter ] [ Facebook Facebook ] [ Kontakt ]
[ Anleitung ] [ Suchen ] [ Profil ] [ Eigene Beiträge ] [ Registrieren ]
[ Login ]
   
Bücher-Shop mit Amazon (Buchkategorien):  C++ : Referenzen zu C++ : C++ Builder : Visual C++ : C# : Java : Spieleprogrammierung : Systemprogrammierung Linux : Software-Entwicklung : .NET : Compilertechnik : Algorithmen & Datenstrukturen : Objektorientierung : Entwurfsmuster : UML : eXtreme Programming : Scrum : Projektmanagement : Software-Testing : Datenbanken : Tom DeMarco : Dilbert : User Friendly
C/C++ Forum :: FAQ - MFC ::  'cout' im Fenster ausgeben  
Gehen Sie zu Seite 1, 2  Weiter   Zeige alle Beiträge auf einer Seite 		Auf Beitrag antworten
Autor Nachricht
Noch_Student
Mitglied

Benutzerprofil
Anmeldungsdatum: 07.01.2008
Beiträge: 62
Beitrag Noch_Student Mitglied 17:42:21 17.01.2008   Titel:   'cout' im Fenster ausgeben            Zitieren
Hi, :)
weiß jemand, ob es eine Funktion gibt, welche die Zeilen, die in einer Anwendung mit 'cout' ausgegeben werden, in einem Fenster (z.B. in einem ListBox oder in EditFeld) ausgibt?
Werbeunterbrechung
CStoll
Moderator

Benutzerprofil
Anmeldungsdatum: 17.10.2005
Beiträge: 17913
Beitrag CStoll Moderator 17:53:28 17.01.2008   Titel:              Zitieren
Ansi C++ kennt keine Listboxen und ähnliches, bietet dir aber einiges an Handlungsfreiheit, wohin du Stream-Ausgaben schicken willst - in Form von Stream-Buffern. Da mußt du nur einen Stream-Buffer schreiben, der dein Steuerelement als Ziel verwendet (schau dir die vorhandenen basic_streambuf-Kinder an, um auf den Geschmack zu kommen) - und cout mittels rdbuf() auf diesen umbiegen.

_________________
Wo ich bin, herrscht Chaos. Leider kann ich nicht überall sein.

Moderator im MFC- und C++-Board und Magazin-Autor
Noch_Student
Mitglied

Benutzerprofil
Anmeldungsdatum: 07.01.2008
Beiträge: 62
Beitrag Noch_Student Mitglied 10:59:18 18.01.2008   Titel:              Zitieren
Soll ich für den Stream-Buffer eine Klasse shreiben?
Habe in diesem Forum gefunden:
http://www.c-plusplus.de/forum/viewtopic-var-t-is- ....... sc-and-highlight-is-streambuf-and-start-is-10.html
CStoll
Moderator

Benutzerprofil
Anmeldungsdatum: 17.10.2005
Beiträge: 17913
Beitrag CStoll Moderator 11:07:49 18.01.2008   Titel:              Zitieren
Noch_Student schrieb:
Soll ich für den Stream-Buffer eine Klasse shreiben?
Ja, genau darauf wollte ich hinaus.

_________________
Wo ich bin, herrscht Chaos. Leider kann ich nicht überall sein.

Moderator im MFC- und C++-Board und Magazin-Autor
Noch_Student
Mitglied

Benutzerprofil
Anmeldungsdatum: 07.01.2008
Beiträge: 62
Beitrag Noch_Student Mitglied 11:39:59 18.01.2008   Titel:              Zitieren
Damit bin ich überfordert... :(
jencas
Mitglied

Benutzerprofil
Anmeldungsdatum: 27.07.2005
Beiträge: 798
Beitrag jencas Mitglied 17:19:15 18.01.2008   Titel:              Zitieren
... hoffentlich nicht auch noch mit der englischen Sprache:

http://www.williamwilling.com/blog/?p=74
Werner Salomon
Mitglied

Benutzerprofil
Anmeldungsdatum: 02.07.2005
Beiträge: 1862
Beitrag Werner Salomon Mitglied 14:49:55 19.01.2008   Titel:              Zitieren
Da die Aufnahme einer neuen Zeile in einem CListBox-Objekt nur ein einfacher AddString ist, ist so ein streambuf für eine CListBox eine einfache Sache - vorausgesetzt, man weis wie das überhaupt geht. Ich habe sowas vor Urzeiten mal gemacht.
C/C++ 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// File ListBoxStreambuf.h
#pragma once
// Bem.: erfordert ein #include <stdafx.h> (MFC) vor diesem include
#include <streambuf>
#include <iostream>
#include <string>
#include <vector>


namespace listboxsb_detail
{
    // --   hier werden die Zeichen-Typ-Konvertierungen erledigt
    template< typename E, typename Traits >
    int addString( CListBox& box, const std::basic_string< E, Traits >& line, E, std::basic_streambuf< E, Traits >* )
    {
        // keine Konvertierung E == TCHAR
        return box.AddString( line.c_str() );
    }

    template< typename Traits >
    int addString( CListBox& box, const std::basic_string< char, Traits >& line, wchar_t, std::streambuf* sb )
    {
        // Konvertierung von char -> wchar_t
        std::vector< wchar_t > wstr( line.size() + 1, wchar_t(0) );
        const std::ctype< wchar_t >& ctype_ = std::use_facet< std::ctype< wchar_t > >( sb->getloc() );
        const char* in = line.c_str();
        ctype_.widen( in, in + line.size(), &wstr[0] );
        return box.AddString( &wstr[0] );
    }
}


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStreambuf : public std::basic_streambuf< E, Traits >
{
public:
    explicit basic_ListBoxStreambuf( CListBox& box )
        : m_box( box )
        , m_line()
        , m_index( -1 )
    {}

    int ListBoxIndex() const { return m_index; }

protected:
    virtual int_type overflow( int_type m = Traits::eof() )
    {
        if( Traits::eq_int_type( m, Traits::eof() ) )
            return Traits::not_eof( m );
        const E c = Traits::to_char_type( m );
        if( c == E('\n') )      // LF: Zeilenende
        {
            // --   neue Zeile anhängen
            m_index = listboxsb_detail::addString( m_box, m_line, TCHAR(), this );
            if( m_index < 0 )
                return Traits::eof();   // Fehler Ausgabe ging schief
            m_line = std::basic_string< E, Traits >(); // m_line.clear();
        }
        else
            m_line.append( 1, c );  // Zeichen für später merken
        return m;
    }

private:
    CListBox& m_box;
    std::basic_string< E, Traits > m_line;
    int m_index;    // current Index of the added line
};


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStream : public std::basic_ostream< E, Traits >
{
    typedef std::basic_ostream< E, Traits > base_type;
public:
    explicit basic_ListBoxStream( CListBox& box )
        : base_type( &m_sb )
        , m_sb( box )
    {}
private:
    basic_ListBoxStreambuf< E, Traits > m_sb;
};

typedef basic_ListBoxStreambuf< char > ListBoxStreambuf;
typedef basic_ListBoxStream< char > ListBoxStream;
C/C++ 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// File ListBoxStreambuf.h
#pragma once
// Bem.: erfordert ein #include <stdafx.h> (MFC) vor diesem include
#include <streambuf>
#include <iostream>
#include <string>
#include <vector>


namespace listboxsb_detail
{
// -- hier werden die Zeichen-Typ-Konvertierungen erledigt
template< typename E, typename Traits >
int addString( CListBox& box, const std::basic_string< E, Traits >& line, E, std::basic_streambuf< E, Traits >* )
{
// keine Konvertierung E == TCHAR
return box.AddString( line.c_str() );
}

template< typename Traits >
int addString( CListBox& box, const std::basic_string< char, Traits >& line, wchar_t, std::streambuf* sb )
{
// Konvertierung von char -> wchar_t
std::vector< wchar_t > wstr( line.size() + 1, wchar_t(0) );
const std::ctype< wchar_t >& ctype_ = std::use_facet< std::ctype< wchar_t > >( sb->getloc() );
const char* in = line.c_str();
ctype_.widen( in, in + line.size(), &wstr[0] );
return box.AddString( &wstr[0] );
}
}


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStreambuf : public std::basic_streambuf< E, Traits >
{
public:
explicit basic_ListBoxStreambuf( CListBox& box )
: m_box( box )
, m_line()
, m_index( -1 )
{}

int ListBoxIndex() const { return m_index; }

protected:
virtual int_type overflow( int_type m = Traits::eof() )
{
if( Traits::eq_int_type( m, Traits::eof() ) )
return Traits::not_eof( m );
const E c = Traits::to_char_type( m );
if( c == E('\n') ) // LF: Zeilenende
{
// -- neue Zeile anhängen
m_index = listboxsb_detail::addString( m_box, m_line, TCHAR(), this );
if( m_index < 0 )
return Traits::eof(); // Fehler Ausgabe ging schief
m_line = std::basic_string< E, Traits >(); // m_line.clear();
}
else
m_line.append( 1, c ); // Zeichen für später merken
return m;
}

private:
CListBox& m_box;
std::basic_string< E, Traits > m_line;
int m_index; // current Index of the added line
};


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStream : public std::basic_ostream< E, Traits >
{
typedef std::basic_ostream< E, Traits > base_type;
public:
explicit basic_ListBoxStream( CListBox& box )
: base_type( &m_sb )
, m_sb( box )
{}
private:
basic_ListBoxStreambuf< E, Traits > m_sb;
};

typedef basic_ListBoxStreambuf< char > ListBoxStreambuf;
typedef basic_ListBoxStream< char > ListBoxStream;
C/C++ 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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// File ListBoxStreambuf.h
#pragma once
// Bem.: erfordert ein #include <stdafx.h> (MFC) vor diesem include
#include <streambuf>
#include <iostream>
#include <string>
#include <vector>


namespace listboxsb_detail
{
    // --   hier werden die Zeichen-Typ-Konvertierungen erledigt
    template< typename E, typename Traits >
    int addString( CListBox& box, const std::basic_string< E, Traits >& line, E, std::basic_streambuf< E, Traits >* )
    {
        // keine Konvertierung E == TCHAR
        return box.AddString( line.c_str() );
    }

    template< typename Traits >
    int addString( CListBox& box, const std::basic_string< char, Traits >& line, wchar_t, std::streambuf* sb )
    {
        // Konvertierung von char -> wchar_t
        std::vector< wchar_t > wstr( line.size() + 1, wchar_t(0) );
        const std::ctype< wchar_t >& ctype_ = std::use_facet< std::ctype< wchar_t > >( sb->getloc() );
        const char* in = line.c_str();
        ctype_.widen( in, in + line.size(), &wstr[0] );
        return box.AddString( &wstr[0] );
    }
}


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStreambuf : public std::basic_streambuf< E, Traits >
{
public:
    explicit basic_ListBoxStreambuf( CListBox& box )
        : m_box( box )
        , m_line()
        , m_index( -1 )
    {}

    int ListBoxIndex() const { return m_index; }

protected:
    virtual int_type overflow( int_type m = Traits::eof() )
    {
        if( Traits::eq_int_type( m, Traits::eof() ) )
            return Traits::not_eof( m );
        const E c = Traits::to_char_type( m );
        if( c == E('\n') )      // LF: Zeilenende
        {
            // --   neue Zeile anhängen
            m_index = listboxsb_detail::addString( m_box, m_line, TCHAR(), this );
            if( m_index < 0 )
                return Traits::eof();   // Fehler Ausgabe ging schief
            m_line = std::basic_string< E, Traits >(); // m_line.clear();
        }
        else
            m_line.append( 1, c );  // Zeichen für später merken
        return m;
    }

private:
    CListBox& m_box;
    std::basic_string< E, Traits > m_line;
    int m_index;    // current Index of the added line
};


template< typename E, typename Traits = std::char_traits< E > >
class basic_ListBoxStream : public std::basic_ostream< E, Traits >
{
    typedef std::basic_ostream< E, Traits > base_type;
public:
    explicit basic_ListBoxStream( CListBox& box )
        : base_type( &m_sb )
        , m_sb( box )
    {}
private:
    basic_ListBoxStreambuf< E, Traits > m_sb;
};

typedef basic_ListBoxStreambuf< char > ListBoxStreambuf;
typedef basic_ListBoxStream< char > ListBoxStream;

Damit man das bequem integrieren kann habe ich noch ein Helferlein zum Umschalten der streambufs gebastelt.
C/C++ 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
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
// File IosSwitch.h
#pragma once
#include <ios>

class IosSwitch  
{
public:
    IosSwitch()
        : m_ios(0)
        , m_sbMerk(0)
    {}

    IosSwitch( std::basic_ios< char >& ios, std::streambuf* sb )
        : m_ios( &ios )
        , m_sbMerk( ios.rdbuf( sb ) )
    {}

    ~IosSwitch()
    {
        release();
    }

    void set( std::basic_ios< char >& ios, std::streambuf* sb )
    {
        release();

        m_ios = &ios;
        m_sbMerk = ios.rdbuf( sb );
    }

private:
    void release()
    {
        if( m_ios )
        {
            delete m_ios->rdbuf( m_sbMerk );
        }
    }

    // ---  Members
    std::basic_ios< char >* m_ios;
    std::streambuf*         m_sbMerk;

    // ---  nicht kopierbar
    IosSwitch( const IosSwitch& );
    IosSwitch& operator=( const IosSwitch& );
};
C/C++ 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
// File IosSwitch.h
#pragma once
#include <ios>

class IosSwitch
{
public:
IosSwitch()
: m_ios(0)
, m_sbMerk(0)
{}

IosSwitch( std::basic_ios< char >& ios, std::streambuf* sb )
: m_ios( &ios )
, m_sbMerk( ios.rdbuf( sb ) )
{}

~IosSwitch()
{
release();
}

void set( std::basic_ios< char >& ios, std::streambuf* sb )
{
release();

m_ios = &ios;
m_sbMerk = ios.rdbuf( sb );
}

private:
void release()
{
if( m_ios )
{
delete m_ios->rdbuf( m_sbMerk );
}
}

// --- Members
std::basic_ios< char >* m_ios;
std::streambuf* m_sbMerk;

// --- nicht kopierbar
IosSwitch( const IosSwitch& );
IosSwitch& operator=( const IosSwitch& );
};
C/C++ 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
// File IosSwitch.h
#pragma once
#include <ios>

class IosSwitch  
{
public:
    IosSwitch()
        : m_ios(0)
        , m_sbMerk(0)
    {}

    IosSwitch( std::basic_ios< char >& ios, std::streambuf* sb )
        : m_ios( &ios )
        , m_sbMerk( ios.rdbuf( sb ) )
    {}

    ~IosSwitch()
    {
        release();
    }

    void set( std::basic_ios< char >& ios, std::streambuf* sb )
    {
        release();

        m_ios = &ios;
        m_sbMerk = ios.rdbuf( sb );
    }

private:
    void release()
    {
        if( m_ios )
        {
            delete m_ios->rdbuf( m_sbMerk );
        }
    }

    // ---  Members
    std::basic_ios< char >* m_ios;
    std::streambuf*         m_sbMerk;

    // ---  nicht kopierbar
    IosSwitch( const IosSwitch& );
    IosSwitch& operator=( const IosSwitch& );
};

Jetzt brauchst Du nur noch in Deiner View- oder Dialogklasse einen Member von IosSwitch aufzunehmen:
C/C++ Code:
private:
    IosSwitch m_coutSwitch;  // erfordert include "IosSwitch.h"
C/C++ Code:
private:
IosSwitch m_coutSwitch; // erfordert include "IosSwitch.h"
C/C++ Code:
private:
    IosSwitch m_coutSwitch;  // erfordert include "IosSwitch.h"

und bei der Initialisierung oder InitDialog auf den ListBoxStreambuf umschalten
C/C++ Code:
BOOL DeinDialog::OnInitDialog()
{
    CDialog::OnInitDialog();
    // ... usw.
    m_coutSwitch.set( std::cout, new ListBoxStreambuf( m_listBox ) );
    return TRUE;
}
C/C++ Code:
BOOL DeinDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// ... usw.
m_coutSwitch.set( std::cout, new ListBoxStreambuf( m_listBox ) );
return TRUE;
}
C/C++ Code:
BOOL DeinDialog::OnInitDialog()
{
    CDialog::OnInitDialog();
    // ... usw.
    m_coutSwitch.set( std::cout, new ListBoxStreambuf( m_listBox ) );
    return TRUE;
}

das erfordert natürlich den CListBox-Member 'm_listBox' und die includes "ListBoxStreambuf.h" und <iostream>. Anschließend landen alle Ausgaben auf cout in dieser ListBox.
Noch ein Tipp: setze das Sort-Flag der ListBox auf FALSE.

jencas schrieb:
http://www.williamwilling.com/blog/?p=74

Das beschreibt das Umschalten von cout auf eine Konsole, nicht in ein MFC-Element.

Gruß
Werner
jencas
Mitglied

Benutzerprofil
Anmeldungsdatum: 27.07.2005
Beiträge: 798
Beitrag jencas Mitglied 14:09:31 21.01.2008   Titel:              Zitieren
Werner Salomon schrieb:

jencas schrieb:
http://www.williamwilling.com/blog/?p=74

Das beschreibt das Umschalten von cout auf eine Konsole, nicht in ein MFC-Element.


Wo er Recht hat, hat er Recht. Mea culpa, mea maxima culpa ;-)
Noch_Student
Mitglied

Benutzerprofil
Anmeldungsdatum: 07.01.2008
Beiträge: 62
Beitrag Noch_Student Mitglied 17:42:59 21.01.2008   Titel:              Zitieren
Hallo Werner Salomon, :)
alles, du vorgeschlagen hast, funktioniert gut! Super Danke! :live: :live:
Kannst du evtl. noch was empfehlen:
alle meine vorherige "\t" werden jetzt als Quadrate angezeigt. Kann man das irgendwie vermeiden?
Und noch eine Frage: die horizontale Bildlaufleiste erscheint nicht im ListBox, Einträge werden abgeschnitten.

Übrigens kann man alles auf eine Konsole so ausgeben:
C/C++ Code:
AllocConsole();
freopen("conout$", "w", stdout);
C/C++ Code:
AllocConsole();
freopen("conout$", "w", stdout);
C/C++ Code:
AllocConsole();
freopen("conout$", "w", stdout);

Habe selber probiert.


Zuletzt bearbeitet von Noch_Student am 17:45:30 21.01.2008, insgesamt 1-mal bearbeitet
Werner Salomon
Mitglied

Benutzerprofil
Anmeldungsdatum: 02.07.2005
Beiträge: 1862
Beitrag Werner Salomon Mitglied 13:33:54 22.01.2008   Titel:              Zitieren
Noch_Student schrieb:
Kannst du evtl. noch was empfehlen:
alle meine vorherige "\t" werden jetzt als Quadrate angezeigt. Kann man das irgendwie vermeiden?

Ja - das ist ein nicht darstellbares Steuerzeichen. Das kann man aber auch bei den Resources der ListBox einstellen: 'Use Tabstops = TRUE'.

Falls Du Sonderwünsche hast, kann man es auch selber implementieren. Füge dazu in der Klasse basic_ListBoxStreambuf ab der Zeile 59 folgenden oder einen ähnlichen Code ein:
C/C++ Code:
        else if( c == E('\t') ) // TAB: Tabulator
        {
            const unsigned TABSIZE = 8; // oder ein anderer Wert, je nach dem wo der Tabulator hin soll
            m_line.append( TABSIZE - m_line.size() % TABSIZE , ' ' );
        }
C/C++ Code:
else if( c == E('\t') ) // TAB: Tabulator
{
const unsigned TABSIZE = 8; // oder ein anderer Wert, je nach dem wo der Tabulator hin soll
m_line.append( TABSIZE - m_line.size() % TABSIZE , ' ' );
}
C/C++ Code:
        else if( c == E('\t') ) // TAB: Tabulator
        {
            const unsigned TABSIZE = 8; // oder ein anderer Wert, je nach dem wo der Tabulator hin soll
            m_line.append( TABSIZE - m_line.size() % TABSIZE , ' ' );
        }

so richtig 'gut' sieht das aber erst aus, wenn Du eine nicht-proportionale Schrift (z.B. Courier) als Font für die ListBox wählst.

Noch_Student schrieb:

Und noch eine Frage: die horizontale Bildlaufleiste erscheint nicht im ListBox, Einträge werden abgeschnitten.

In den Resources der ListBox 'Horizontal Scroll = TRUE' einstellen (funktioniert aber bei mir nicht!? :confused: ).
@Edit: Ah - ein MFC-Problem siehe hier. Den dort vorgeschlagenen Aufruf könnte man auch schön in den ListBoxStreambuf aufnehmen.

Gruß
Werner


Zuletzt bearbeitet von Werner Salomon am 13:40:01 22.01.2008, insgesamt 1-mal bearbeitet
C/C++ Forum :: FAQ - MFC ::  'cout' im Fenster ausgeben  
Gehen Sie zu Seite 1, 2  Weiter		 Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können keine Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum nicht antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.de ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info, www.c-sar.de, www.c-plusplus.net und www.baeckmann.de enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.