Länge von Array über Zeiger abfragen (für eigene string-Funktion)

heine789

Hallo zusammen!

Komme bei meinem Problem einfach nicht weiter.

Wenn ich folgendes habe:

char s1[40];

dann kann ich mit sizeof(s1) die Anzahl der Elemente meines Arrays abfragen. Ich erhalte genau 40.

Wie mach ich dass in folgendem Fall:

char* s1 = new char[40];

Wie kann ich hier die Länge meines Array abfragen???
(Brauche ich, um abzufragen, ob genug Platz für einen anderen String ist, den ich da reinkopieren will. Programmiere nämlich die cstring funktionen, als Vorbereitung auf eine Klausur)

Würde mir sehr weiterhelfen, wenn ich das wüsste.

Gruß heine

Ponto

Das geht so nicht. Du musst dir die Länge selbst merken.

std::vector<char>

Gnom

Vielleicht gehts wenn du mit dem *-Operator auf die Werte zugreifen die der Zeiger gespeichert hat. Dann kannst du einfach die Größe wie bei einem normalen Array herausfinden.

Bsp:
int *pointer1;
int Wert = 1;

pointer1 = &Wert;

cout << *pointer1 << endl;

So irgendwie geht das glaube ich

interpreter

Wenn du das Ende des Arrays nicht mit einem Terminatorsymbol markierst, geht es nicht.

michba

heine789 schrieb:

Programmiere nämlich die cstring funktionen, als Vorbereitung auf eine Klausur

Du willst also die Länge eines C-Strings ermitteln?
Da kannst du dir damit helfen, dass ein C-String mit dem Zeichen '\0' bzw. 0 (nicht '0' ) endet (siehe Post von interpreter).
Also alle Zeichen zählen, bis ein 0 kommt.

PS: zum Aufbau von C-Strings siehe auch hier

size_t StringLength( const char* string )
{
  size_t length = 0;
  while( *string++ )
     ++length;
  return length;
}

heine789

Danke GehtSo! Werds gleich mal ausprobieren.
Hier mein kleines Progrämmchen. Vielleicht hat jemand noch einen Verbesserungsvorschlag.

Gruß heine

// string.cpp
#include <iostream>
#include <cstdlib>

using namespace std;

size_t my_strlen(const char* s);
char* my_strcpy(char* s1, const char* s2);
char* my_strcat(char* s1, const char* s2);

int main()
{
	const char* name = "abzdefghijklmnopqrstuvwxyz";
	char* buffer = new char[100];

	cout << my_strlen(name) << '\n';
	cout << my_strcpy(buffer, "Test-String") << '\n';
	cout << my_strcat(buffer, " Hier kommt der zweite Teil") << '\n';

	return 0;
}

size_t my_strlen(const char* s)
{
	size_t t = 0;
	while( *(s + t) != '\0' ) t += 1;

	return t;
}

char* my_strcpy(char* s1, const char* s2)
{
	int i;

	for(i = 0; i < my_strlen(s2); ++i)
	{
		*(s1 + i) = *(s2 + i);
	}

	*(s1 + i) = '\0';	// string abschließen

	return s1;
}

char* my_strcat(char* s1, const char* s2)
{
	int start = my_strlen(s1);	// Position von '\0' im Zielarray ermitteln
	int i;

	for(i = 0; i < my_strlen(s2); ++i)
	{
		*(s1 + start + i) = *(s2 + i);
	}

	*(s1 + start + i) = '\0';	// string abschließen

	return s1;
}

Du könntest auch einfach s[t] schreiben statt *(s+t)

interpreter

und statt

while( *(s + t) != '\0' )

das:

while(s[t])

heine789

Vielen Dank für eure Hilfe!

Ich wollte auf die Schreibweise mit [] möglichst verzichten.

Zur Vollständigkeit noch meine Version von strcmp:

int my_strcmp(const char* s1, const char *s2)
{
	int n = 0;

	size_t s1length = my_strlen(s1);
	size_t s2length = my_strlen(s2);

	// Den längsten string ermitteln
	n = s1length < s2length ? s2length : s1length;

	for(int i = 0; i < n; ++i)
	{
		if(static_cast<int>(*(s1 + i)) != static_cast<int>(*(s2 + i)))
		{
			if(static_cast<int>(*(s1 + i)) > static_cast<int>(*(s2 + i)))
			{
				return 1;		// s1 ist lexikografisch > s2
			} else {
				return -1;		// s2 ist lexikografisch < s2
			}
		}
	}

	return 0;					// beide strings sind lexikografisch gleich groß
}

Gruß heine