char * strcpy ( char * dest, const char * src );

Copy string.
Copies the content pointed by src to dest stopping after the terminating null-character is copied.
dest should have enough memory space allocated to contain src string.

Parameters.

dest
Destination string. Should be enough long to contain string2.
string2
Null-terminated string to copy.

char * strcat ( char * dest, const char * src );

Append string.
Appends src string to dest string. The terminating null character in dest is overwritten by the first character of src. The resulting string includes a null-character at end.

Parameters.

dest
Pointer to a null-terminated string with enough space allocated to contain both src and dest.
src
Null-terminated string to append.

http://www.cplusplus.com/ref/cstring/

size_t strlen ( const char * string );

Return string length.
Returns the number of characters in string before the terminating null-character.

Parameters.

string
Null-terminated string.

Return Value.
The length of string.

Aber wenn du wirklich C++ machst, vergiss C-Strings:

Defined in ANSI-C

Nimm lieber std::string und konsorten http://www.cppreference.com/cppstring/index.html

gut und wie kann ich das "sauber" machen?

nimm strncpy und strncat (mit 'nem N in der mitte). damit kannste buffer overflows vermeiden, weil du die länge des buffers angeben kannst...
:xmas2:

neomic schrieb:

gut und wie kann ich das "sauber" machen?

nimm strncpy und strncat (mit 'nem N in der mitte). damit kannste buffer overflows vermeiden, weil du die länge des buffers angeben kannst...
:xmas2:

heist dann da wird der rest dann einfach abgeschnitten oder reserviert der dann den neuen speicher?

heist dann da wird der rest dann einfach abgeschnitten oder reserviert der dann den neuen speicher?

wird abgeschnitten wenn's nicht passt. es wird nicht willkürlich speicher alloziert, hast also volle kontrolle drüber

neomic schrieb:

gut und wie kann ich das "sauber" machen?

nimm strncpy und strncat (mit 'nem N in der mitte). damit kannste buffer overflows vermeiden, weil du die länge des buffers angeben kannst...
:xmas2:

Was spricht gegen 'std::copy'?

habe ich bei strcpy() und strcat() eventuelle speicherleaks zu befürchten bzw muss ich mich um die genug großen speicherbereiche selber kümmern oder machen die funktionen das von selbst?

Bei strcpy() und strcat() musst Du Dich selbst um den benötigten Arbeitsspeicher kümmern. Genauso bei strncpy() und strncat()!

neomic schrieb:

wenn ja wie kann ich das sauber machen?

In Standard-C++ nur mit std::string (bzw. std::wstring). Etwa so:

#include <string>
// ...
    std::string quelle = "Hello ";
    std::string ziel;
    // ..
    ziel = quelle; // statt strcpy()
    ziel += "World"; // statt strcat();

Gruß
Werner

neomic schrieb:

wenn ja wie kann ich das sauber machen?

In Standard-C++ nur mit std::string (bzw. std::wstring).

Der Vollständigkeit halber möchte ich nochmal auf den Weg mit boost::array<char> und std::copy hinweisen (ist natürlich nicht für Strings geeignet aber char-Arrays können ja prinzipiell auch etwas anderes ausdrücken als Strings):

std::size_t const len = 10; // Die Länge der Daten.

boost::array<char, len> ch_arr;
char const* data = "Die Daten"; // Irgendwelche Binärdaten.
std::copy(data, data + len, ch_arr.begin());

mfg

zudem hab ich mich dabei gefragt, wie die leute das noch zu c zeiten gemacht haben...

na mit den 'strnXXX()' funktionen oder was ähnliches selbtgebasteltes...
:xmas2:

na mit den 'strnXXX()' funktionen oder was ähnliches selbtgebasteltes...
:xmas2:

hab ich mir auch schon iwie gedacht...^^

folgenes soll ein kleiner hex parser werden:

char input[]="test";
    int h=strlen(input);
    int i=h*3+2;
    char str[i];
    memset(str,'\0',i);
    for(int i=0;i<h;i++){
        char out[3];
        sprintf(out,"%02x",static_cast<unsigned char>(input[i]));
        strcat(out,",");
        strcat(str,out);
    }
    strcat(str,"00");
    cout<<str<<endl;

muss ich hier mit irgendwelchen problemen rechnen? kann man das auch eleganter (-ohne <string>-) lösen?

ich hab ein programm das mit <string> klappt... jedoch erhöhen die streams (z.b. <iostream> oder <string>) die größe meiner .exe ungemein

Solange Du nur mit std::string arbeitest benötigst Du kein #include <iostream>.

neomic schrieb:

(und ich wollte ein nur knapp 20kb großes programm schreiben).

Warum?

zudem hab ich mich dabei gefragt, wie die leute das noch zu c zeiten gemacht haben, weil es ist ja anscheinend nicht das leichteste an der sprache

Aso, du willst was lernen. Dann machs doch mal ganz ohne die Funktionen aus <cstring>. So richtig übel Handgestrickt mit netten Schlaufen und bösen Ösen

Solange Du nur mit std::string arbeitest benötigst Du kein #include <iostream>.

ja aber #include <string> ist 70 kb groß..

Werner Salomon schrieb:

Warum?

wieso denn nicht? es ist ein kleines projekt...

THX 1138 schrieb:

Aso, du willst was lernen. Dann machs doch mal ganz ohne die Funktionen aus <cstring>. So richtig übel Handgestrickt mit netten Schlaufen und bösen Ösen

hab ich auch schon und es klappt...

int GetLength(char *pchar){
    int i=0;
    while(pchar[i])i++;
    return i;
}
int Find(char *pchar,char *pcharsearch){
    bool done=false;
    int i=0;
    while(!done){
        int j=0,k;
        if(pchar[i]==pcharsearch[0]){
            k=i;
            while(pchar[i]==pcharsearch[j]){
                j++;
                if(j==GetLength(pcharsearch))done=true;
                if(!done)i++;
            }
            if(pchar[i]!=pcharsearch[j])i=k;
        }
        if(!done)i++;
        if(i==GetLength(pchar)){
                done=true;
                i=-1;
        }
    }
    return i;
}
void Replace(char *pchar,char *pcharreplace,char *pcharout,int entrypoint,int replacewidth=0){
    int length_pcharreplace=GetLength(pcharreplace);
    for(int i=0;i<entrypoint;i++){
        pcharout[i]=pchar[i];
    }
    for(int i=0;i<length_pcharreplace;i++){
        pcharout[i+entrypoint]=pcharreplace[i];
    }
    for(int i=entrypoint;i<GetLength(pchar)-replacewidth+1;i++){
        pcharout[i+length_pcharreplace]=pchar[i+replacewidth];
    }
}
void Add(char *pchar,char *pcharreplace,char *pcharout){
    Replace(pchar,pcharreplace,pcharout,GetLength(pchar));
}

wieso denn nicht? es ist ein kleines projekt...

Weil die Zeiten mit 64kB RAM vorbei sind?

Weil die Zeiten mit 64kB RAM vorbei sind?

jetzt sag mir doch wieso denn nicht?

Ne sorry, es gibt bei PC Anwendungen eigentlich keinen Grund, auf Grösse zu optimieren. Mach das ruhig so, um zu lernen. Aber benutz dann lieber die std::strings und ihre Methoden, die sind sicherer und einfacher zu nutzen weil du dich nicht ums Speichermanagment kümmern brauchst.

Weil die Zeiten mit 64kB RAM vorbei sind!

Ne sorry, es gibt bei PC Anwendungen eigentlich keinen Grund, auf Grösse zu optimieren. Mach das ruhig so, um zu lernen. Aber benutz dann lieber die std::strings und ihre Methoden, die sind sicherer und einfacher zu nutzen weil du dich nicht ums Speichermanagment kümmern brauchst.

1. meine <string> version klappt 100% ist mir aber bei großen datenmengen zu langsam da immer der shic copy-constructor aufgerufen wird
2. ich will auch was über dynamische speicherverwaltung lernen, rate mal warum ich c++ lerne und nicht delphi

1. meine <string> version klappt 100% ist mir aber bei großen datenmengen zu langsam da immer der shic copy-constructor aufgerufen wird
2. ich will auch was über dynamische speicherverwaltung lernen, rate mal warum ich c++ lerne und nicht delphi

1. ev. kannste da was mit call-by-reference optimieren
2. dann lern c und nicht c++
3. nicht böse werden, sind gut gemeinte tipps

1. ev. kannste da was mit call-by-reference optimieren
2. dann lern c und nicht c++
3. nicht böse werden, sind gut gemeinte tipps

zu 1: wie geht das denn?^^
zu 2: new und delete sind doch erst mit c++ dazugekommen oder irre ich? o.0
zu 3: ich werd nich böse nur ernst, weil ihr die ganze zeit um den heißen brei drumrumredet... also nich denken ich mag euch net oder so (das stimmt nämlich net)

Ansonsten kurz erklärt

Call by Value:

void do_something_with_it( HugeClass it );  // Copy-Ctor wird aufgerufen

Call by Reference:

void do_something_with_it( HugeClass& it );  // Copy-Ctor wird nicht aufgerufen, it kann verändert werden

Call by Const-Reference:

void do_something_with_it( const HugeClass& it );  // Copy-Ctor wird nicht aufgerufen, it kann nicht verändert werden

meine <string> version klappt 100% ist mir aber bei großen datenmengen zu langsam da immer der shic copy-constructor aufgerufen wird

Und du glaubst, das lässt sich nicht optimieren? Zeig mal den Code!

neomic schrieb:

2. ich will auch was über dynamische speicherverwaltung lernen, rate mal warum ich c++ lerne und nicht delphi

Der Trick an der dynamischen Speicherverwaltung ist, dass sie richtig eingesetzt extrem effizient ist, der Programmierer aber trotzdem nicht viel davon sieht. Man kapselt den Zeigerkram einfach weg. Direkt am Speicher rumzuwurschteln machst du eigentlich nur in der Kapselung und in C.

neomic schrieb:

zu 1: wie geht das denn?^^

Du benutzt Referenzparameter. Das erspart die Kopie.

neomic schrieb:

zu 2: new und delete sind doch erst mit c++ dazugekommen oder irre ich? o.0

Ja und? malloc und free sind die äquivalenten Funktionen in C. Der Bedarf nach new und delete kam daher, dass bei C++ Objekten auch der Konstruktor aufgerufen werden muss (wobei das denke ich auch mit Templates gelöst werden kann, die gabs damals aber noch nicht).

neomic schrieb:

zu 3: ich werd nich böse nur ernst, weil ihr die ganze zeit um den heißen brei drumrumredet...

Nein, wir suchen nur ein einfacher und schöner lösbares Problem. Und strcpy und Konsorten sind nunmal nicht der C++ Weg.