trotzdem raffe ich nicht wo da jetzt der unterschied liegt

hmm na eine konstante Variable kannst du nicht mehr ändern . Du weißt ihr einmal einen Wert zu, den du NIE mehr ändern kannst, wenn du es doch versuchst, wird dich der Compiler schon 'informieren'

Beispiel:

const int iConst = 10;
double dNotConst = 10.10;

dNotConst = 23.0; // OK!
iConst = 12; // FEHLER!

# include <iostream>
using namespace std;

double pi=3.14159;
double x, y, radius = 1.5;

int main()
{

x = pi * radius* radius ;
y = 2* pi * radius;

cout << "\nKreisberechnung\n" << endl;

cout<<" radius: " <<radius<< endl;
cout <<"umfang : " << y << endl;
cout<<" flaeche "<<x << endl;
return 0;

}

ja aber nur in diesm programm oder???
bzw. wenn cih pi in diesem programm nicht const double sondern nur double zuweise ändert sich auch nichts

LOL , natürlich nur in deinem Programm, und wenn du sie global definierst, dann in deinem 'ganzen' Programm, wenn jedoch nur lokal, dann eben nur im entsprechenden Gültigkeitsbereich

Das sich da nichts ändert ist auch klar...bei einer konstanten Variable geht es auch nur um Schreibschutz. Du schützt damit den zugweisenen Wert von unbeabsichtigter Veränderung (durch den Prgorammierer).

Du schützt damit den zugweisenen Wert von unbeabsichtigter Veränderung (durch den Prgorammierer).

Sei dir nicht sicher, dass das immer unbeabsichtigt ist :p

Habe dein Programm mal sicher gemacht, damit du siehts wie das geht:

#include <iostream>
using namespace std;

const double pi=3.14159;
const double x = 0;
const double y = 0;
const double radius = 1.5;

int main()
{
	*const_cast< double* >( &x ) = pi * radius * radius ;
	*const_cast< double* >( &y ) = 2 * pi * radius;

	cout << "\nKreisberechnung\n" << endl;

	cout<<" radius: " <<radius<< endl;
	cout <<"umfang : " << y << endl;
	cout<<" flaeche "<<x << endl;
	return 0;
}

Am besten mach alle Variablen immer konstant, dann änderst du sie nie unbeabsichtig.

Habe dein Programm mal sicher gemacht, damit du siehts wie das geht:

Oh nein Oh nein...Also das:

Am besten mach alle Variablen immer konstant

ist ganz bestimmt nicht sinnvoll, warum differenziert man denn dann zwischen konstanten Variablen und nicht konstanten V. ?
Außerdem ist ein const_cast sowieso zu vermeiden.

Also wenn das Programm schon 'sicher' sein soll dann so:

#include <iostream>
using namespace std;

const double PI = 3.14159;

int main()
{
    double dX, dY, dRadius = 1.5;

    dX = PI * dRadius * dRadius ;
    dY = 2 * PI * dRadius;

    cout << "\nKreisberechnung\n\n";

    cout << "Radius: " << dRadius << endl;
    cout << "Umfang: " << dY << endl;
    cout << "Fl" << static_cast<unsigned char>(132) << "che: " << dX << endl;

    return (0);
}

PS: Hab mir mal erlaubt ungarische Notation einzubauen -sieht schöner aus- :p

in einem 5 zeiler einfach ein muss, da verliert man so schnell die übersicht.. :p

hm ok, aber ich dachte es geht darum (hast du ja selbst gesagt ):

dragon90# schrieb:

damit du siehts wie das geht:

dragon90# schrieb:

Am besten mach alle Variablen immer konstant, dann änderst du sie nie unbeabsichtig.

Weiß nicht genau, ob das ein Witz sein soll, aber das halte ich absolut nicht für sinnvoll. Wenn sich der Wert ändert dann Variablen sonst konstante Variablen (so ein blödes Wort), also Konstanten.

chrische

1. Ist die zusätzliche Schreibarbeit um die Konstanten dann doch zu ändern (Konstante? Ändern? wie jetzt ) viel zu hoch
2. Darf man Konstanten nicht ändern (ach )

Ich habe erst kürzlich einen Fall erlebt, wo mit const_cast eine Konstante änderbar gemacht und auch geändert wurde, und sie wurde nicht wirklich geändert (obwohl keine Compilefehler) undefiniertes Verhalten wollen wir wohl nicht oder?

IMHO ist die einzige Daseinsberechtigung für const_cast, wenn man eine API benutzt die nicht const-correct ist, von der man aber weiss dass sie bestimmte Werte nicht selbst verändert.

Am besten mach alle Variablen immer konstant, dann änderst du sie nie unbeabsichtig.

Habe dein Programm mal sicher gemacht, damit du siehts wie das geht:

#include <iostream>
using namespace std;

const double pi=3.14159;
const double x = 0;
const double y = 0;
const double radius = 1.5;

int main()
{
	*const_cast< double* >( &x ) = pi * radius * radius ;
	*const_cast< double* >( &y ) = 2 * pi * radius;

	cout << "\nKreisberechnung\n" << endl;

	cout<<" radius: " <<radius<< endl;
	cout <<"umfang : " << y << endl;
	cout<<" flaeche "<<x << endl;
	return 0;
}

das ist schlicht undefiniert. eine const qualifikation wegzucasten ist nur zulässig, wenn das zugrundeliegende objekt nicht const qualifiziert ist.

IMHO ist die einzige Daseinsberechtigung für const_cast, wenn man eine API benutzt die nicht const-correct ist, von der man aber weiss dass sie bestimmte Werte nicht selbst verändert.

camper schrieb:

das ist schlicht undefiniert. eine const qualifikation wegzucasten ist nur zulässig, wenn das zugrundeliegende objekt nicht const qualifiziert ist.

Hm, das heisst für mich dass o.a. auch schon undefiniert ist?
(Schade :()

EDIT:
Wo bin ich nur mit meinen Gedanken - natürlich nur wenn das zugrundeliegende Objekt nicht const ist. Was aber wenn doch? (Also ich übergebe ein const Objekt an eine API, die eine non-const Referenz erwartet, dieses aber nicht ändert - muss ich jetzt meine Konstante wegen dieser API non-const definieren, oder darf ich const_casten?)

Am besten mach alle Variablen immer konstant, dann änderst du sie nie unbeabsichtig.

Habe dein Programm mal sicher gemacht, damit du siehts wie das geht:

#include <iostream>
using namespace std;

const double pi=3.14159;
const double x = 0;
const double y = 0;
const double radius = 1.5;

int main()
{
	*const_cast< double* >( &x ) = pi * radius * radius ;
	*const_cast< double* >( &y ) = 2 * pi * radius;

	cout << "\nKreisberechnung\n" << endl;

	cout<<" radius: " <<radius<< endl;
	cout <<"umfang : " << y << endl;
	cout<<" flaeche "<<x << endl;
	return 0;
}

Was aber wenn doch? (Also ich übergebe ein const Objekt an eine API, die eine non-const Referenz erwartet, dieses aber nicht ändert - muss ich jetzt meine Konstante wegen dieser API non-const definieren, oder darf ich const_casten?)

du darfst casten. relevant ist 7.1.5.1/4, frei übersetzt: "Abgesehen von mutabledeklarierten membervariablen, die verändert werden dürfen, resultiert jeder versuch, ein konstantes objekt während seiner lebenszeit zu verändern, in undefiniertem verhalten". der cast selbst konstituiert ja noch keine veränderung.

CodeFinder schrieb:

Hat es einen speziellen Grund, das mich alle wiederholen ?

das bezieht sich auf wen?

Ein Schreibzugriff über const_cast ist nur dann sicher (wie bereits erwähnt), wenn das Originalobjekt nicht const ist.

Ich dachte es wäre eindeutig, dass das nen Scherz ist.