Zeiger funktioniert nicht

[Stefan H. (stefan_h143)]

Hallo zusammen,

Könntet ihr mir vielleicht bei einem vermutlich totalen Anfängerfehler 
helfen?

Ich möchte eigentlich nur mit einer Funktion eine Variable bis zu einem 
gewissen Grad inkrementieren und dann wieder zurück setzten.

Allerdings funktioniert der Zugriff über den Zeiger irgendwie nicht und 
die Variable verändert sich nicht.

void increment (int *value, int lower_bound, int upper_bound )
{
  if (*value < upper_bound)
  {
    *value++;
  } else
  {
    *value = lower_bound;
  }
  
}


int main()
{
static int step=0;


increment(&step,0,13);


}

Ich mache natürlich normalerweise noch was damit. Ich habe jetzt nur mal 
den Ausschnitt gepostet, da das Programm doch recht groß ist.

Kann mir kurz einer auf die Sprünge helfen, warum er die Variable nicht 
verändert?

Gruß
stefan

[nicht"Gast" (Gast)]

(*value)++;

https://de.wikibooks.org/wiki/C-Programmierung:_Liste_der_Operatoren_nach_Priorit%C3%A4t

[Rezy (Gast)]

Moin,

das Inkrement hat eine höhere Priorität als die Dereferenzierung. 
Entsprechend führst du implizit gerade

*(value++)

aus und nicht das, was du eigentlich willst:

(*value)++

Du inkrementierst aktuell also nur die Adresse des pointers lokal in der 
Funktion.

[Stefan H. (stefan_h143)]

Top! Danke für die schnelle Antwort :)

Ja... hätte man drauf kommen können

[Stefan F. (Gast)]

Es muss
> (*value)++;

heißen, dann klappt es. Der ++ Operator hat Vorrang, wenn du die 
Klammern weg lässt.

Nachtrag: Oh, zu spät. Das Testen hat eine Weile gedauert.

[Stefan H. (stefan_h143)]

Stefan F. schrieb:
> Nachtrag: Oh, zu spät. Das Testen hat eine Weile gedauert.

Trotzdem Danke für die Mühe :)

[Wilhelm M. (wimalopaan)]

Der Fehler wäre nicht passiert, wenn Du const (read-only) verwendet 
hättest.

[Stefan H. (stefan_h143)]

Wilhelm M. schrieb:
> Der Fehler wäre nicht passiert, wenn Du const (read-only) verwendet
> hättest.

Wie meinst du das? ich möchte die ja verändern und nicht nur lesen. also 
an welcher Stelle das const?

[Wilhelm M. (wimalopaan)]

Stefan H. schrieb:
> Wilhelm M. schrieb:
>> Der Fehler wäre nicht passiert, wenn Du const (read-only) verwendet
>> hättest.
>
> Wie meinst du das? ich möchte die ja verändern und nicht nur lesen. also
> an welcher Stelle das const?

void increment (int* const value, const int lower_bound, const int upper_bound ) {...}

Mache alles const, wenn Du kannst, und nur non-const, wenn Du musst.

Bei einem Zeiger gibt es immer zwei Objekte, einmal die Zeigervariable 
und einmal das Zielobjekt. Du hast einen sog. Output-Parameter, d.h. das 
Zielobjekt ist non-const.

[Wilhelm M. (wimalopaan)]

Stefan H. schrieb:
> Wie meinst du das?

Bei einem Zeiger gibt es vier Möglichkeiten:

int* ptr1;
int* const ptr2 = ...;
const int* ptr3;
const int* const ptr4 = ...;

Bei ptr1 und ptr3 ist die Zeigervariable selbst non-const, was nur 
sinnvoll ist, wenn man sie als Iterator verwenden will.

Bei ptr3 und ptr4 ist das Zielobjekt const, also read-only,

Bei ptr1 und ptr2 ist das Zielobjekt non-const.

[Wilhelm M. (wimalopaan)]

In einer Parameterliste bei der Funktionsdefinition macht man 
sinnvollerweise alle Parametervariablen const. Denn mit dem Namen der 
Parametervariablen ist eine Bedeutung verbunden. Eine Wertänderung ist 
oftmals auch eine Bedeutungsänderung, und deswegen unerwünscht.

Bei lokalen Variablen sollte man auch alles const machen wenn es geht, 
dann kann man die Initialisierung nicht vergessen. Bei C++ kann man las 
DT auch auto nehmen, dann kan man selbst bei non-const die 
Initialisierung nicht vergessen.

[Stefan H. (stefan_h143)]

Wilhelm M. schrieb:
> Bei einem Zeiger gibt es vier Möglichkeiten:

Eieiei :D

Also wenn ich eine Variable mit einem Zeiger verwenden will, verhindere 
ich durch Variante 2 quasi, dass sich die Zugriffsadresse ändert. Ich 
kann aber weiterhin den Wert verändern.

Wenn ich die zugriffsadresse ändern möchte, also zb. um ein Array 
durchzugehen ohne den Inhalt zu verändern, nehme ich Variante 4.

Ist das so richtig?

Hast du da auf die Schnelle vielleicht eine Quelle wo man sich das mal 
genau anschauen kann?

[Bernd (Gast)]

void incrementiere_den_wert(int* const value)
{
  (*value)++;
}

void incrementiere_die_adresse(const int* value)
{
  *(value++);
}

void veraendere_nichts(const int* const value)
{
}

Diese 3 Varianten gibt es.

Bernd

[Wilhelm M. (wimalopaan)]

Stefan H. schrieb:
> Also wenn ich eine Variable mit einem Zeiger verwenden will, verhindere
> ich durch Variante 2 quasi, dass sich die Zugriffsadresse ändert. Ich
> kann aber weiterhin den Wert verändern.

Ja.

Stefan H. schrieb:
> Wenn ich die zugriffsadresse ändern möchte, also zb. um ein Array
> durchzugehen ohne den Inhalt zu verändern, nehme ich Variante 4.

Nein, ptr3.

Stefan H. schrieb:
> Hast du da auf die Schnelle vielleicht eine Quelle wo man sich das mal
> genau anschauen kann?

Leider nein. Ich kann Dir nur umgekehrt sagen, dass ein Lehrbuch, dass 
es nicht so macht bzw. nicht darauf hinweist, sein Geld nicht Wert ist.

Wilhelm M. schrieb:
> Mache alles const, wenn Du kannst, und nur non-const, wenn Du musst.

Dieser Satz ist ganz wichtig! Denke darüber nach und setze diese Regel 
kompromisslos ein.

[Wilhelm M. (wimalopaan)]

Bernd schrieb:
> Diese 3 Varianten gibt es.

Eine hast Du vergessen ...

[Stefan H. (stefan_h143)]

Wilhelm M. schrieb:
> Nein, ptr3.

Hoppla, da hab ich mich vertippt... Meinte die 3. Bei 4 ist ja alles 
unveränderbar.

Super, Danke für eure Erklärungen :)

[Dirk B. (dirkb2)]

Der Compiler weiß, das es nicht verändert werden soll.
Wenn du es über die Variable/Zeiger probierst, meckert er.

Zur Compiletime. Nicht während der Laufzeit.

Das heißt aber nicht, dass du es nicht mit unsauberer/böser 
Programmierung trotzdem ändern kannst.