If Blöcke

Hallo.

Ich übe mit dem Buch C++ Programmierung von André Willms und hab jetzt einen Codeausschnitt aus dem Buch, mit dem ich noch nicht ganz klar komme. Es handelt sich um eine einfache Liste.

#include <iostream.h>
#include "eliste.h"

EListe::~EListe()
{
	ELKnot *cur=head,*next;
	while(cur)
		{
			next=cur->next;
			delete(cur);
			cur=next;
		}
}

int EListe::Insert(int d, unsigned long pos)
{
	if((pos<1)||(pos>(quantity+1))) return(0);
	if(quantity==0)
		{
			head=tail=new ELKnot(d);
			return(quantity+=(head!=0));
		}
	ELKnot *knot;
	if((pos--==1)&&[b](knot=new ELKnot(d,head))[/b])
		{
			head=knot;
			quantity++;
			return(1);
		}
	if(!pos) return(0);[i]
	ELKnot *cur=head;
	while(--pos) cur=cur->next;

	[b]if(knot=new ELKnot(d,cur->next))[/b]
		{
			cur->next=knot;
			if(!(knot->next)) tail=knot;
			quantity++;
			return(1);
		}
	return(0);
}

int EListe::Delete(unsigned long pos)
{
	if((pos<1)||(pos>quantity--)) return(0);
	ELKnot *cur;
	if(pos==1)
		{
			cur=head->next;
			int data=head->data;
			delete(head);
			head=cur;
			if(quantity<2) tail=head;[b]
			return(data);
		}
	ELKnot *last;
	cur=head;
	while(--pos) {last=cur; cur=cur->next;}
	if(cur==tail) tail==last;
	last->next=cur->next;
	int data=cur->data;
	delete(cur);
	return(data);
}

void EListe::Show(void)
{
	cout << "Listengroesse :" << quantity << "\n\n";
	ELKnot *cur=head;
	int x=1;
	while(cur)
		{
			cout << "Element " << x++ << ":" << cur->data << "\n";
			cur=cur->next;
		}
}

int EListe::Push(int d)
{
	return(Insert(d,quantity+1));
}

int EListe::Pop(void)
{
	return(Delete(quantity));
}

int EListe::Enqueue(int d)
{
	return(Insert(d,quantity+1));
}

int EListe::Dequeue(void)
{
	return(Delete(1));
}

Kann mir irgendjemand erklären, was das fett-makierte für eine Abfrage ist?

Ich dachte in If-Blöken wird immer auf wahr/unwahr überprüft und dann kommt es zu irgendeiner Ausführung.

Wenn ich mir jetzt aber diese beiden Vergleiche/Überprüfungen anschaue, dann siehts für mich so aus, als ob der Zeiger knot anstatt überprüft zu werden ein neues ELKnot-Objekt auf dem Heap erzeugt.

Das ergibt für mich dann aber irgendwie keinen Sinn.

Kann mir jemand mal mein Hirn wieder gerade rücken und mir vertellen was da in Wirklichkeit steht? ^^

net 0

C++ Starter schrieb:

Wenn ich mir jetzt aber diese beiden Vergleiche/Überprüfungen anschaue, dann siehts für mich so aus, als ob der Zeiger knot anstatt überprüft zu werden ein neues ELKnot-Objekt auf dem Heap erzeugt.

es wird ein neues objekt erzeugt, dem zeiger die adresse zugewiesen und anschliessend geprüft ob's geklappt hat (zeiger == 0 heisst fehlschlag). c++ nimmt das mit true/false in if-abfragen nicht so genau. 0 ist false, alles andere ist true

Ponto

Das ist eine abkürzende Schreibweise. Wenn du zum Beispiel folgendes hast:

int * p;
if (p = new int) {

}

Bedeutet das das gleiche wie:

int * p;
p = new int;
if (p) {

}

Denn es gilt, das der Wert einer Zuweisung (p = new int), das Zugewiesene ist. Dies erlaubt dann Ketten wie p = a = b = 0, was bedeutet p = (a = (b = 0)). Hätte nun b = 0 keinen Wert, könnte man dies nicht schreiben. Das kann zum Beispiel passieren, wenn man vergisst beim operator= einen Rückgabewert zu definieren.

Der Wert von p = new int ist nun der neue Wert, also die Adresse des neuen ints. In der if-Abfrage wird der Wert in einen bool konvertiert, wobei jeder Wert ungleich 0 wahr ist.

Die Überprüfung der Adresse hat den Zweck zu erkennen, ob die Allozierung eines neuen ints geklappt hat. Falls es zu der Abfrage kommt, wird diese jedoch immer gelingen und ist hier eigentlich sinnlos. Denn falls kein Speicher alloziert werden konnte, wird dich entweder das Betriebssystem rauskicken, oder es wird die std::bad_alloc Exception geworfen.

Shlo

net schrieb:

0 heisst fehlschlag.

Ne, heißt nicht. Nur new(std::nothrow) liefert einen null-Zeiger falls kein Speicher reserviert werden konnte, ansonsten wird std::bad_alloc geworfen.

net 0

Shlo schrieb:

net schrieb:

0 heisst fehlschlag.

Ne, heißt nicht. Nur new(std::nothrow) liefert einen null-Zeiger falls kein Speicher reserviert werden konnte, ansonsten wird std::bad_alloc geworfen.

ach so. hab ich's mit malloc verwechselt

Hey Leute!

Danke für eure ausführliche Hilfe!

Endlich hab ich da nen durchblick

Vielen Dank!!!

schönes WE noch

Shlo

net schrieb:

ach so. hab ich's mit malloc verwechselt

Ja, die Gemeinsamkeiten sind schon verblüffend