4. Grösse eines Stings ermitteln

Grösse eines Stings ermitteln

  • B

    Inwiefern ist Länge != Größe? OK vieleicht meinst du ja, dass die Größe inklusive Nullbyte 1 mehr ist als die Länge 😃

    In deinem letzten Beispiel hat das Argument von sizeof den Typ char[255]. Im ersten Beispiel LPSTR, was wohl ein typedef auf char* sein dürfte. Logisch, dass da was unterschiedliches rauskommt.

    0
  • D

    das da was unterschiedliches rauskommt is schon klar, aber wie bekomme ich die grösse???

    Das mit Länge und grösse meine ich wie folgt:

    ---------------------------
    char Buffer[100];
    int i;

    strcpy(Buffer,"Test");

    i = strlen(Buffer);
    ---------------------------

    => länge ist 5 grösse ist aber 100!!! 😮

    5 und 100 ist ja doch ein kleiner unterschied oder 😃

    0
  • B

    achso. Ne das geht nicht.

    0
  • ?

    #define NUM_ELEMENTS(x) (sizeof((x)) / sizeof((x)[0])) 😕

    0
  • G

    Du kannst in deiner Funktion nicht die (maximale) Größe des Strings herausfinden, da du nur den Zeiger "Text" zur Verfügung hast. Und ein Zeiger ist bei Systemen mit 32-Bit-Adressierung logischerweise immer 4 Byte groß.
    Du musst also die Größe des String-Buffers zusätzlich übergeben, was dann folgendermaßen aussieht:

    int CFile::ReadFileUntilSign(LPSTR Text, UINT iBufferSize)
{
char szBuffer[1];
int i=0, iTextLength;
DWORD dwCharRead;

iTextLength = iBufferSize;

...
}

    Der Aufrufer ruft dann deine Funktion so auf:

    CFile file;
char szText[256] = "Hallo Welt!";
...
file.ReadFileUntilSign(szText, sizeof(szText));
    0
  • ?

    Bashar warum geht das nicht?

    #include <iostream>
#include <stdlib.h>

#define NUM_ELEMENTS(x) (sizeof((x)) / sizeof((x)[0])) 

int main(int argc, char *argv[])
{
  char Buffer[100];
  strcpy(Buffer, "Test");
  std::cout << NUM_ELEMENTS(Buffer) << std::endl;
  system("PAUSE");  
  return 0;
}

    Gibt 100 aus.

    0
  • S

    Original erstellt von <Sam>:
    **Bashar warum geht das nicht?
    **

    weil es hier um char* geht und nicht um char[]

    bei einem char* muss man die 'größe' selber wissen.

    0
  • D

    Wenn ich mich aber auf den User (in diesen Fall ich), der die Klasse verwendet verlasse, dann...

    Ist das für den Allerwertesten 😃

    muss doch gehen! Och meno!

    Aber Trozdem danke 😉

    0
  • S

    Original erstellt von Der_Knob:
    **Wenn ich mich aber auf den User (in diesen Fall ich), der die Klasse verwendet verlasse, dann...

    Ist das für den Allerwertesten 😃

    muss doch gehen! Och meno!
    **

    sicher gehts: merks dir einfach.
    in C macht man es halt so

    foo(string, string_größe)
    in C++ macht man es so
    foo(string)
    wobei string eine klasse ist die aus dem string und der größe des strings besteht.

    in C kannst du dir mit strukturen helfen, welche den char* und die größe speichern - aber das ist C untypisch.

    0
  • D

    ok, ok - ich mach es ja jetzt mit übergabe

    *gebe mich geschlagen* 🙄

    0
  • D

    Original erstellt von Shade Of Mine:
    in C kannst du dir mit strukturen helfen, welche den char und die größe speichern - aber das ist C untypisch.*

    Nicht wirklich. Zumindest sieht man recht oft dieses (in C89) nicht ganz legale C-Schnippselchen: [Nicht der Schnipsel ist nicht legal, sondern das Zugreifen auf z.B. array[n-1]]

    #include <stdlib.h>

struct string {
    size_t len;
    char   array[1]; /* C99: 'char array[]' */
};

string* make_string (int n) {
    string* s;

    s = malloc (sizeof *s + n);
    if (s) {
        s->len = n;
/*      s->array[0] = '\0'; */
    }
    return s;
}

    [ Dieser Beitrag wurde am 21.01.2003 um 18:25 Uhr von Daniel E. editiert. ]

    0
Anmelden zum Antworten