Diskussion:C++-Programmierung/ Weitere Grundelemente/ Prozeduren und Funktionen

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Was ist mit diesem Satz gemeint?[Bearbeiten]

Dieser Wert kann Konstant sein, dass heisst man kann ihn innerhalb der Funktion nicht mehr ändern oder er kann als Deklaration übergeben. Der erste Teil ist klar, aber was nach dem oder gesagt wird, ist unverständlich.

E^(nix) 15:49, 16. Aug 2005 (UTC)

Meines Wissens wird bei Call-by-Value eine Kopie übergeben, die zwar geändert werden kann, nach dem Verlassen der Funktion ihren Wert aber wieder verliert. Daher ist die Aussage, dass der Wert innerhalb der Funktion nicht mehr geändert werden kann, sowieso nicht korrekt. -- Daniel B 19:28, 16. Aug 2005 (UTC)
Ist unter dem Namen call-by-value nicht auch eine Übergabe per const inklusive? (void f(const int i);). Dann wäre die Aussage, wie sie neu formuliert ist, richtig (s. Kapitel), sonst müsste man den Satz noch herausschneiden --Sliver 17:42, 17. Aug 2005 (UTC)

Rückgabewert beim Überladen wirklich gleich?[Bearbeiten]

Wenn wir schon mal dabei sind: Im Abschnitt Überladen folgere ich aus dem Satz

"Ungültig ist aber nur eine unterschiedlicher Rückgabewert. "

das der Datentyp des Rückgabewerts aller überladenen Funktionen gleich sein muss. Stimmt das überhaupt?

E^(nix) 15:47, 16. Aug 2005 (UTC)

Stimmt nicht, jedoch reicht das alleinige ändern des Rückgabewerts nicht aus. Die Signatur darf sich also nicht nur durch den Rückgabewert unterscheiden, sondern muss auch noch einen Unterschied bei den Parametern haben. --Stefan Kögl 07:46, 17. Aug 2005 (UTC)

Eine Referenz deklariert man mit dem Referenzoperator &[Bearbeiten]

Was für ein Blödsinn und niemand von uns hat was gemerkt. Wir sollten dies zum Anlass nehmen, dieses Buch einmal gründlich zu überarbeiten und alle Aussagen zu verifizieren. Ich wäre auf jeden Fall dabei, da ich mich in den nächsten Wochen wieder eingehend mit c++ beschäftige.

Habe schon mal diesen Artikel überarbeitet, dabei die Unterschiede anhand des Themas Speicher herausgearbeitet.

E^(nix) 23:28, 17. Aug 2005 (UTC)

Signatur einer Funktion[Bearbeiten]

Galileo-Computing, Bestandteil einer Funktion

in C: Signatur enthält den Typ des Rückgabeparameters

in Java: Signatur einer Methode: Name + Reihe von Typen der Übergabeparameter, z.B.: überladene Methoden müssen trotzdem den gleichen Rückgabewert haben

Das ist falsch:

"Wenn das Array nur gelesen werden soll, deklariert man den Zeiger als const."

...

"int const* array"


1.) Ob der Zeiger unveränderlich ist oder nicht schützt die Werte nicht vor Veränderung.

2.) Im angegeben Beispiel "int const* bla" bezieht sich 'const' auf 'int', nicht auf '*'.

Also besser:

Um sicherzugehen, dass die Werte im Feld von der aufgerufenen Funktion nicht verändert werden, sollten die Werte als unveränderlich (const) deklariert werden.

...

const int *array

Das Beispiel ist richtig wie es ist und auch genau so gemeint. Der Satz darüber war natürlich Quatsch, hab ihn berichtigt. Danke für den Hinweis :)
Zu deinen ersten beiden Punkten möchte ich noch einen Dritten ergänzen:
In C++: Signatur enthält Name und Reihenfolge der Typen der Übergabeparameter, überladene oder virtuelle Methoden müssen nicht den gleichen Rückgabetyp besitzen.
Damit hätten wir dann auch die in diesem Buch behandelte Programmiersprache besprochen. Ich hoffe du gehörst nicht zu den Menschen die C und C++ gleichsetzen, wenn doch solltest du dir das ganz schnell Abgewöhnen. Beide Sprachen haben Ihre Vor- und Nachteile, ebenso haben sie Gemeinsamkeiten und Unterschiede. ;-)
--Prog 00:37, 3. Mai 2008 (CEST)

Parameternamen nicht notwendig?[Bearbeiten]

Auf der Seite steht: Bei einer Deklaration ist es nicht nötig, die Parameternamen mit anzugeben, denn diese sind für den Aufruf der Funktion nicht relevant. Es ist allerdings üblich die Namen dennoch mit anzugeben um zu verdeutlichen was der Parameter darstellt. Der Compiler ignoriert die Namen in diesem Fall einfach, weshalb es auch möglich ist den Parametern in der Deklaration und der Definition unterschiedliche Namen zu geben. Allerdings wird davon aus Gründen der Übersichtlichkeit abgeraten.

Nuvola-inspired-terminal.svg
1 '"`UNIQ--source-00000000-QINU`"'

Wenn ich in dieser Funktion bei der Deklaration "x" weglasse, gibt der Compiler mir folgende Fehlermeldung aus:

test.cpp: In function ‘int f(int)’:
test.cpp:4: error: ‘x’ was not declared in this scope

So sieht die Funktion aus:

Nuvola-inspired-terminal.svg
1 '"`UNIQ--source-00000004-QINU`"'

Oder meint der Autor mit Deklaration den Aufruf der Funktion? Selbst dann schlägt der Kompiliervorgang fehl:

Nuvola-inspired-terminal.svg
1 '"`UNIQ--source-00000008-QINU`"'

Fehlermeldung:

test.cpp: In function ‘int main()’:
test.cpp:8: error: ‘x’ was not declared in this scope

Ist Deklaration und Definition nicht das Gleiche? --tim 11:42, 28. Sep. 2008 (CEST)

Nein, Deklaration und Definition sind 2 absolut verschiedene Sachen, auch wenn Sie ähnlich aussehen:
Nuvola-inspired-terminal.svg
1 '"`UNIQ--source-0000000C-QINU`"'
Ein Deklaration teilt dem Compiler mit, wie eine Funktion verwendet wird. Die Definition sagt ihn was die Funktion tut. Für den Funktionsaufruf ist also nur die Deklaration nötig. Erst der Linker benötigt dann auch die Definition. Gruß --Prog 20:32, 28. Sep. 2008 (CEST)

Arrays[Bearbeiten]

Ich denke, dass wir den gesamten Array-Teil mit dieser Seite zusammenlegen sollten. Für Anfäger sind die Schritte nämlich sehr schwierig nachzuvollziehen. Besonders verwirrend ist der Zusammenhang von Arrays und Zeigern (... int const* array ...), auf welchen der Artikel nicht näher eingeht. --tim 12:25, 28. Sep. 2008 (CEST)

Mein Senf dazu[Bearbeiten]

Um es kurz zu machen ;-)

  • Dass man Namen in einem C++-Programm beliebig oft deklarieren, aber nur einmal definieren darf (mit bestimmten Ausnahmen), gilt für alle Entitäten (One definition rule). Dies muss nicht bei jeder einzelnen Entität wiederholt werden. Ach ja, dafür hätte man natürlich erstmal solch grundlegenden Begrifflichkeiten wie "Name", "Entität", "Deklaration" und "Definition" usw. am Anfang des Buches einführen müssen, klar. Aber dafür hat man es später dann viel einfacher, da man dann darauf aufbauen kann. Es erklärt sich viel einfacher und es lernt sich viel einfacher.
  • Es werden nicht "alle Anweisungen nach einem return ignoriert". Beispiel:
 int foo(int x)
 {
    if(x<0) return 0;
    int y=x;                  // wird selbstverständlich ausgeführt, wenn x>=0 ist, ...
    while(x>0) { ++y; x=/2; } // ...auch wenn es nach der Return-Anweisung steht!
    return y;
 }
  • Was an eine Funktion übergeben wird, wenn sie einen Referenztyp in ihrer Argumentliste hat, ist Sache des Compilers. Es kann eine Adresse einer Variablen sein. Es kann aber auch ein Register oder sonstwas sein, das muss einen als Programmierer eigentlich nicht interessieren. Insbesondere "const-Referenzen" haben oftmals gar keinen Speicherbereich, somit auch keine Adresse, die übergeben werden kann.

Nunja, das soll erstmal reichen. ;-) --RokerHRO 22:00, 16. Mär. 2009 (CET)