Verkettete Liste

Stromberg

Hab mir aus folgendem Thread, mal den Code hier genommen, um mir eine "verkettete Liste" zu verdeutlichen: http://c-plusplus.net/forum/viewtopic-var-p-is-1324660.html#1324660

#include <iostream>
using namespace std;

class SList //1.
{
public:
    typedef int value_type;

private:
    class Node  // Listenelement 2.
    {
    public:
        explicit Node( const value_type& x, Node* next = 0 )
                :m_next( next ), m_value( x )
        {

        }
        Node* m_next;
        value_type m_value;
    };

public:
    SList()     // ersetzt das init()
        : m_kopf( value_type() )
        , m_ende( &m_kopf )
    {}
    ~SList() { clear(); } // immer schön wieder aufräumen

    void push_back( const value_type& x ) // ersetzt das einfuegen() was ein anhaengen() ist
    {
        m_ende->m_next = new Node( x );
        m_ende = m_ende->m_next;
    }

    void clear() // ersetzt das ende()
    {
        for( Node* p = m_kopf.m_next; p; )
        {
            Node* tmp = p;
            p = p->m_next;
            delete tmp;
        }
        m_kopf.m_next = 0;
        m_ende = &m_kopf;
    }

    // --   Ausgabe
    std::ostream& ausgeben( std::ostream& out, const char* delim = "" )
    {
        for( Node* p = m_kopf.m_next; p; p = p->m_next )
        {
            out << p->m_value << delim;
        }
        return out;
    }

private:
    // Kopieren z.Zt. nicht vorgesehen; -> "Regel der drei"
    SList( const SList& );
    SList& operator=( const SList& );

    // --   Member
    Node m_kopf;
    Node* m_ende;
};

int main()
{

    return 0;
}

Also auf den ersten Blick versteh ich noch nicht so viel, und hab auch gleich mal 2 Fragen:
1. Woher kommt die Funktion "value_type()" Z.24? Das ist doch nur der Name vom typedef?
2. Was genau ist die "Regel der 3"?

MfG
Stromberg

Stromberg

Weiß keiner was? Oder is es vll. nur so weit runtergerutscht?

asc

Stromberg schrieb:

Also auf den ersten Blick versteh ich noch nicht so viel, und hab auch gleich mal 2 Fragen:
1. Woher kommt die Funktion "value_type()" Z.24? Das ist doch nur der Name vom typedef?

Das ist keine Funktion sondern das Erzwingen der Standardinitialisierung (Bei einem Integer wäre das 0 bei einem Objekt der Standardkonstruktor...)-

Stromberg schrieb:

2. Was genau ist die "Regel der 3"?

http://tutorial.schornboeck.net/bigthree.htm

Davon abgesehen kannst du auch ein bischen Gedult üben Zum einen ist heute in katholischen Bundesländern ein Urlaubstag, zum anderen ist es ja noch nicht wirklich alt...

cu André

Stromberg

Ja, ja ich weiß, tut mir leid, mir hängen die Feiertage schon zum Hals raus, leb in der Stadt mit den meisten Feiertagen in Deutschland (wer Ahnung hat weiß es^^). Bins halt nich gewöhnt dass nach 12Std noch keiner zurückgeschrieben hat.

Bei folgendem Code hier:

#include <iostream>
using namespace std;

class test
{
    public:
    test(int a_);
    ~test();

    private:
    int m_a;
};

test::test(int a_)
:m_a(a_)
{

}

test::~test()
{

}

typedef int value;
typedef test object;

int main()
{
    value a=value();
    test A(object());

    return 0;
}

ist a=0 und "test A(0)"? Also das "m_a" dann 0 ist? Oder wie ist das nochmal bei Objekten, da hast du gemeint da kommt der Standardkonstruktor hin, aber wie ist das genau gemeint?

MfG
Stromberg

Dann gewöhn Dich dran, Du bist nicht der einzige.

Braunstein

Das sollte gar nicht kompilieren, da test (alias object) keinen Standardkonstruktor hat.
Wenn du einen Konstruktor selbst anlegst, erzeugt dir der Compiler keinen Defaulkonstruktor mehr.

pumuckl

aalso:
erstens:

int main()
{
    value a=value();

da value = int ist, steht hier im Endeffekt

int a = int();

was soviel bedeutet, dass a defaultinitialisiert wird, was bei ints einer 0 entspricht.

zweitens:

test A(object());

ist das gleiche wie

test A(test());

hier machst du also folgendes: du uebergibst dem Konstruktor von A ein temporaeres Objekt vom Typ test. Dieses temporaere Objekt erzeugst du per deafault-Konstruktor. (test() erzeugt dieses temporaere Objekt oder versucht das zumindest).

Der Compiler sollte dir eigentlich diese letzte Zeile um die Ohren schmeissen, denn da du einen Ctor(int) definiert hast, gibts den Default-Ctor nichtmehr (Den copy-Ctor schon, der wird implizit generiert).

Was hingegen funktionieren wuerde ist folgendes:

test A(value());  // ist gleich test A(int());

hier bekommt der Konstruktor von A ein temporaeres int uebergeben, das default-initialisiert wurde (also 0), weshalb danach A.m_a == 0

Stromberg

Das hier funktioniert bei mir aber ohne Fehlermeldung:

test A(object());

!?

Ist der Wert bei einer defaulinitialisierung immer gleich "0"? Oder was ist bei
unsigned int(), unsigned long(), long(), char(), string(), float(), double()........?

MfG
Stromberg

Werner Salomon

Stromberg schrieb:

Das hier funktioniert bei mir aber ohne Fehlermeldung:
test A(object());
!?

Ist der Wert bei einer defaulinitialisierung immer gleich "0"? Oder was ist bei
unsigned int(), unsigned long(), long(), char(), string(), float(), double()........?

Hallo Stromberg,

Falls 'object' ein 'eingebauter' Typ - also char über int bis double - ist, so ist der Wert immer 0. Bei string wird der Defaultkonstruktor aufgerufen und Du erhälst einen leeren String.

Gruß
Werner

Braunstein

test A(object()); macht nicht das was du denkst. Hier wird nicht etwa eine Instanz namens A vom Typ test konstruiert sondern eine Funktion A, die ein test zurückgibt und einen Funktionspointer auf ein weitere derartige Funktion als Parameter erwartet.
Deswegen geht das.
mach einfach mal folgendes

test B(2);
    test A(object());
    B = A;