ich lege einfach ein statisches Array an.

char d[10] // kann aber auch d[100] oder d[1000] sein;

Jetzt muss ich nur aufpassen (mit sprintf) nicht über's Ziel hinauszuschießen.

Ich möchte einfach die maximale Größe des Arrays herausfinden: hier 10

char d[10];
int iLen = strlen(d);

liefert 23

Geht das überhaupt?

char d[10];
int iLen = strlen(d);

liefert 23

Geht das überhaupt?

d ist nicht initialisiert, strlen zählt nur die anzahl der zeichen bis zum ersten '\0'
Kurt

char l[200];
int Size = sizeof l / sizeof l[0]; // Ergebnis 200

Jetzt übergebe ich l an meine Funktion:

void DT_String::_sprintf(const char* apsDest,

Nun ist das Ergebnis plötzlich 4. Hat das was mit dem const zu tun?

int iMaxSize = sizeof apsDest / sizeof apsDest[0];

char tmp[200] = {0};

Wenn du nun möchtest das keiner über das ziel hinausschiesst dann musst du dir die größe merken und mit übergeben

bool DT_String::Fill( char * str , size_t max_len )
{
   char data[] = "Hallo Welt";
   // wir achten darauf das max_len groß genug ist (+1 damit die 0 Terminierung mit gerechnet wird )
   if(max_len < strlen(data)+1)
     return false;  
   snprintf( str , data , max_len );
   return true;
}

// ein auf 200 Zeichen begrenztes char array anlegen
char buffer[200] = {0};
// char array füllen
dt_string.fill(buffer,200);
// Nun steht in dem char array ( buffer ) "Hallo Welt"

Aber snprintf oder sprintf sind nicht sonderlich sicher. Daher empfehle ich dir ( wenn es nicht nur zu Lernzwecken sein sollte ( Denn aus Fehlern lernt man ja bekanntlich)) std::string

// Wir übergeben eine Referenz auf das std::string objekt
void DT_String::Fill( std::string & str )
{
    // Dem string einen neuen String zuweisen
    str = "Hallo Welt";
}

// ein std::string objekt anlegen
std::string str;
// das std::string objekt füllen lassen
dt_str.fill( str );
// jetzt steht in str "Hallo Welt"

war blödsinn...

*g* grad wollte ich dazu was sagen