Gibt es eine Progsprache, bei der man einer Variablen zur Laufzeit einmalig einen Wert zuweisen und sie dann konstant ma

cooky451

Also in allen mir bekannten C-artigen Sprachen wäre eine nachträgliche constness ein Widerspruch. Aber eine konstante Variable mit einem eingelesenen Wert initialisieren, das geht schon:

int foo()
{
  int i;
  std::cin >> i;
  return i;
}

int main()
{
  const int i = foo();
  std::cout << i;
  ++i; // Schöner Compilerfehler.
}

Du kannst dir das natürlich auch als Parameter an eine Funktion übergeben lassen etc., was auch immer genau das bringen soll. (Denn so viel const-correctness ist dann doch leicht übertrieben. ;))

Was aber weiterhin nicht geht, ist ein Array über diese Konstante zu definieren.
(Weshalb ich alloca im Standard will, aber niemand hört auf mich. :()

lol wie noobig.

In Haskell explodiert gleich dein Computer, wenn du versuchst den Wert einer Variablen nachträglich zu ändern... beim EDITIEREN!!

readonly in C#. Aber nur in Konstruktoren.

Wofür soll man das denn gebrauchen können?

_TdZ schrieb:

Wofür soll man das denn gebrauchen können?

Einfaches Beispiel:

Du hast eine, sagen wir mal, 80 Zeilen lange Funktion.

In Zeile 1 weisst du der variable str="C++ sucks" zu.
Dann kannst du dir sicher sein, dass in Zeile 80 C++ immer noch suckt. Das heisst du hast keine verfälschenden Seiteneffekte.

Diese Garantie sorgt dafür, dass du im vornherein gewisse Annahmen beim programmieren treffen kannst.
In diesem Beispiel wäre die Annahme, dass C++ suckt durchgängig gültig.

In dem Sinne noch: C++ suckt

Warum das nützlich ist:

Stell dir einfach vor, es gibt eine Funktion namens volkard();
Diese Funktion möchte andauernd auf den Inhalt von str zugreifen um dessen Inhalt unrechtmäßig abzuändern. Wenn str veränderlich ist, und du in deienr 80-Zeilen Funktion irgendwo einen volkard drin hast, dann kannst du zum Ende der Funktion nicht mehr sicher sein, dass C++ immer noch suckt.

In diesem Beispiel ist volkard der unerwünschte Seiteneffekt.

In einer Sprache, wo Variablen unveränderlich sind, wird der compiler dem volkard auf die Finger klopfen und sagen "Nein, nein, nein lieber volkard. C++ suckt wirklich."

Somit kann man gewisse Fehlerquellen (wie zB die Annahme,dass C++ nicht suckt) schnell und einfach ausschliessen.

geht das nicht bestimmt auch so irgendwie:

#define int const int

:xmas2:

knivil

In C++ etwa so:

struct ConstInt
{
  const int value;
};
...
ConstInt i = { 4 };
i.value++;  // <- Fehler beim Kompilieren

Du kannst gern noch den Zuweisungsoperator als private deklariere und einen Initialisierungskonstruktor hinzufuegen. Das ganze als Template und schon ist es auf double, float, short, ... anwendbar. C++ rules.

cooky451

lolwienoobig schrieb:

Aber Blubb!!!!

Aber die Frage war ja, ob man die Variable im Nachhinein konstant machen kann. Du bist dir also erst auf halber Strecke sicher, dass C++ suckt? :xmas1:

knivil schrieb:

In C++ etwa so:
struct ConstInt
{
  const int value;
};
...
ConstInt i = { 4 };
i.value++;  // <- Fehler beim Kompilieren
Du kannst gern noch den Zuweisungsoperator als private deklariere und einen Initialisierungskonstruktor hinzufuegen. Das ganze als Template und schon ist es auf double, float, short, ... anwendbar. C++ rules.

Du hast leider die Aufgabenstellung nicht verstanden, es hieß zur Laufzeit und nicht zur Kompilezeit.

Wenn's nur um die Compilezeit ginge, dann würde ein einfaches const genügen.