Einen konstanten Wert verändern!

Sir Gossi

Ich möchte hier einen kurzen Beitrag, keine Frage bringen.

Ich habe eine Möglichkeit gefunden, einen konstanten Wert zu verändern.
Dieser Wert liegt im Heap-Speicher. Testet einfach den folgenden Quelltext.
Meine Frage dazu: Ist ein NULL-Zeiger ein Zeiger auf den ersten Speicherbereich oder eine Markierung, dass dieser Zeiger auf nichts zeigt?

#include <iostream>
using namespace std;

int main()
{
	cout << "Ein konstanter Zeiger legt ein Int-Objekt im Heap an." << endl;
	cout << "Ziel ist es, diesen Wert zu AENDERN!" << endl;
	cout << "Dazu durchsucht ein nicht-konstanter Zeiger" << endl;
	cout << "den Speicher nach der Int-Adresse!" << endl << endl;

	const int* pointer = new int(17);
	int* get = 0;

	int c(0);	// Der Zähler.
	do
	{
		++c;	// Zählen, wie viele Speicherstellen bereits
				// gesprungen wurde.
		++get;	// Die Pointer-Adresse suchen und sich
				// selbst aneignen um den int-Wert zu
				// verändern.
		if( get == pointer )
		{
			cout << "Adresse gefunden nach " << c << " Schritten!" << endl;
			cout << "Adresse Original:  " << pointer << endl;
			cout << "Gefundene Adresse: " << get << endl;
			cout << "Inhalt des konstanten (!) Zeigers: " << *pointer << endl;
			cout << "Inhalt veraendern zu: 20" << endl;
			*get = 20;
			cout << "Inhalt des konstanten (!) Zeigers: " << *pointer << endl;
			break;
		}
	} while(true);
	cout << endl << "Der EIGENTLICH konstante Wert wurde veraendert!" << endl;

	cout << endl;

	return 0;
}

otze

const werte sind dazu da, um nicht veränderbar zu sein, wenn mans doch tut, is es schlechter ziel(btw: der weg über die speicheraddresse is uns allen bekannt)

und NULL ist ein define für 0x000000,also ein einfaches 0, somit ist der anfang des speichers damit gemeint.

SideWinder

class Hrhr
{
    public:
        int getsomething () const
        {
            const_cast<Hrhr&>(*this).dosomething();
            return(m_intern);
        }

        void dosomething ()
        {
            m_intern = 5;
        }

     private:
         int m_intern;
};

MfG SideWinder

Sir Gossi

Hmm, also ich hab diesen Weg noch nicht gekannt. Aber ich hab ja auch nicht behauptet, dass ich es wirklich ernsthaft anwenden würde.

C++ bietet eben für jeden etwas.

DrGreenthumb

zum Casten dazu braucht man kein C++

Shade Of Mine

otze schrieb:

und NULL ist ein define für 0x000000,also ein einfaches 0, somit ist der anfang des speichers damit gemeint.

Nö. 0 gibt eine ungülte Adresse an. Kann natürlich auch 0 sein, muss aber nicht.

peterchen

const ist nur ein Spachmittel zur Modellierung von Invarianz, aber kein Sicherheitsmechanismus. Der compiler ist nicht verpflichtet, die unveränderbarkeit zu sichern (es ist ihm aber u.U. erlaubt).

0 ist eine "nirgendwo"-Adresse, die niemals von einem erfolgreichen new oder Adreßoperator auf einen gültigen lvalue zurückgegeben wird. Die C++ - Repräsentation (also im Quelltext) ist immer eine binäre Null, da ist es egal ob man 0 oder das "übliche" NULL (als #define NULL 0) verwendet.

Die interne Maschinenrepresäntation darf aber davon abweichen. Deswegen muß an den Stellen, wo der compiler nicht weiß daß man einen 0-Zeiger meint, der Typ explizit bekannt gemacht werden (z.B. bei variabler Argumentliste)

ssm

SideWinder schrieb:

const_cast<Hrhr&>(*this).dosomething();

MfG SideWinder

es hat nichts mit der Frage zu tun :D, aber ich würde für solche Situazionen, die du beschrieben hast, lieber mutable nutzen.

Sir Gossi

Wenn NULL also nicht den ersten Speicherbereich markiert, worauf zeigt dann Nullzeiger++ ? Ist ein Null-Zeiger ein Zeiger auf eine undefinierte Stelle im Speicher und Nullzeiger++ die Stelle danach?

peterchen

Ist (IIRC) "undefiniert", d.h. der Standard sichert dir überhaupt nix zu.

Wenn Du's trotzdem machst, hängt es natürlich vom Compiler / Plattform ab.

(z.B. Wintel: NULL zeigt auf eine Adresse die betriebssystemsabhängig auf physischen Speicehr gemappt ist oder auch nicht, un der "NULL++" halt eins weiter)

Bashar

Wohin ein Zeiger+1 zeigt, ist AFAIK generell nicht definiert, es sei denn, Zeiger zeigt in ein Array hinein.