[c] Zählen der zeichen einer Zeichenkette

Hi,
hab noch eine Frage. :-(
Wenn von diesen Arrays jeweils Zeiger erstellt und die Felder in einer Funktion hoch zählt wird, muss man ja in Prinzip folgendermaßen (als Beispiel) machen:

Hauptprogramm
C++: 
int reset(*eingabe);
int zaehlen(*eingabe, *pruef );

int main()
{
Definition
   char Einagbe[151] ;       //für die Eingabe
   int  Uebrpruefen[255];  //zählen der zeichen
   
   //Zeiger
   char *eingabe = Eingabe;
   int  *pruef = Uebrpruefen;


     //Zeichenkette einlesen
      reset(*pruef );

      /Zählen des Zeichenanzahls
      zaehlen(*eingabe, *pruef );

   return 0;
}

Funktion zum zurücksetzen
C++: 
int Reset(*pruef)
{
	//Schleife für das Nullsetzen
      for(i = 0; i < 256; i++)
	{
		*(pruef + i) = 0;
	}

return *pruef;
}



Wenn man jedoch den Zeichenanzahl über einen Zeiger in einer Funktion zählen lässt, muss man es folgendermaßen machen lassen? bzw. wie wird es eigentlich gemacht?

Funktion zum Zählen
C++: 
zaehlen(*eingabe, *pruef );
{
      //Zeichenanzahl Zählen
      for(i=0;i<len;i++)
      {
	     *(pruef*(eingabe + i));
      }

    return *(pruef*(eingabe  + i));
}

Lg Bismark
 
Zuletzt bearbeitet:
Hi

1) zum ersten Codeteil: Lässt sich das kompilieren ?!

In den ersten zwei Zeilen musst du bei den Parametern schon angeben, ob sie int/char/etc... sind.

Im main, erste Zeile: Bei "Definition" fehlt wohl // vorne, oder?

Eingabe und Ueberpruefen haben Rechtschreibfehler (falls wen stört...)

Wichtiger: Warum ist Ueberpruefen nicht 256 lang, nur 255?
Es gibt 256 verschiedene char-Werte (entweder 0 bis 255 oder -128 bis +127).
Aber auch wenns nur bis 256 geht, musst du hier die Anzahl nehmen und auch die 0 mitzählen.
=256

Die zwei Zeiger in den nächsten Zeilen sind überflüssig.
Du kannst die ursprünglichen Variablen auch als Zeiger verwenden, sind ja auch nichts anderes.

Bei den Funktonsaufrufen daruner: Alle * weg!
Du willst ja die Zeiger auf die kompletten Arrays übergeben, nicht den Wert des ersten Arrayelements.

2) Zu Reset: Zeile 1: Dasselbe wie oben schon erwähnt, Typ des Parameters mitangeben.

Zeile in der Schleife: Warum so kompliziert? pruef[ i ] würde es auch tun.

Das return: Warum gibst du den ersten von 256 Nullern zurück? Wenn man im main einen Nuller braucht, kann man auch einfach 0 schreiben und ist nicht auf den Returnwert angewiesen :).
Nimm als Rückgabetp void und lass das return komplett weg, das braucht keiner.

3) Zu zaehlen: Erste Zeile: Parametertypen, außerdem Rückgabetyp her und Strichpunkt weg.

Bei der Schleife: Wo kommt len auf einmal her?

In der Schleife und Returnwert: Ohoh. Du addierst die Adresse von eingabe und i.
Das Ergebnis multiplizierst ((!), Multiplizieren von Pointern?!) du mit der Adresse von pruef.
Das Ergebnis nimmst du wieder als Adresse und willst den Wert, wo sie hinzeigt.
Wenn du das alles hast, was machst du dann mit dem Wert? Nichts.
...Da ist Verbesserungsbedarf

Gruß
 
Zuletzt bearbeitet:
Hi,
hab bei den meisten sachen nicht aufgepasst beim posten.
Mein problem ist halt ob man mit Zeigern - trottz dessen, dass Array auch zeiger sind - auf Arrays Zeigen kann und die Zeiger auf Arrays, z.B. folgendermaßen bearbeiten kann:

C: 
pruef[1] = 0;

Da ich paar mal im Internet mehrmals folgendes gelesen hatte:

C: 
for(i = 0; i < 256; i++)
   {
      *(pruef + i) = 0;
   }

Wie gesatgt, meine frage ist halt, beim zählen der Zeichenanzahl, ob man auch folgendermaßen beim zeiger machen kann:

C: 
*(pruef*(eingabe + i))


@ Arrays sind wie zeiger:
Hab gelesen, dass Arrays eine Adresse einer Adresse sind und Arrays/Felder der Name einer adresse sind


Lg Bismark
 
Zuletzt bearbeitet:
Arrays sollen Adressen von Adressen sein? Nur wenn du ein int-Array hast und als Werte Adressen nimmst.
Generell ist ein Array eine Ansammlung von Variablen mit dem gleichen Typ, diese liegen im Speicher genau hintereinander (ohne andere Sachen oder Leerräume dazwischen).
Die Variable im Programm hat die Adresse des ersten Elements.

C++: 
*(pruef + i) = 0;
ist das Gleiche wie
C++: 
pruef[i] = 0;

Beispiel: Angenommen, man hat ein char-Array c und die Adresse in der Variable ist 100
Das char-Array hat 3 chars, sind daher auf den Adressen 100, 101 und 102.
*(c + 1) ergibt jetzt was?
c+1 ist 100+1 ist 101, und *101 zeigt auf den cahr mit der Adresse 101
c[1] ist auch der char mit Adresse 101
c[0] ist auch der char wäre auf Adresse 100 und c[2] auf 102

Und dazu:
C++: 
*(pruef*(eingabe + i))
hab ich mich ja eigentlich schon geäußert...
*xyz nimmt den Wert von xyz als Adresse und greift auf diese Adresse zu.
abc*xyz ist aber eine mathematische Multiplikation und hat mit Pointern nichts zu tun!
Du multiplizierst hier Speicheradressen, das ist in den seltensten Fällen sinnvoll...
 
Auch Pointer müssen keine Adressen von Adressen sein.
Pointer sind int mit einer Adresse als Wert.
Die Adresse kann von einem float sein, von einem double, einem Objekt einer Klasse, einem int...
Kann natürlich auch die Adresse von einem int sein, das wieder eine Adresse hat; muss aber nicht so sein.

Ein Pointer hat wie jedes normale int auch einen Variablennamen. Das hat überhaupt nichts mit Feldern zu tun.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück