Hinzufügen null-terminator an char-Zeiger ist, bei der Verwendung von strcpy

Ich habe ein Programm, das versucht, die strcpy() Funktion. Ich weiß, dass, wenn man benutzt ein char-array wie: char array[10] null-terminator kann eingestellt werden durch: array[0] = '\0'; Allerdings, wie würde ich mich über die Einstellung der null-terminator(en) bei der Verwendung von char-Zeigern?

EDIT: Das Programm kompiliert, gibt aber Müll als Ausgabe

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
    char *target;
    char *src = "Test";

    target = malloc(sizeof(char));
    src = malloc(sizeof(char));

     strcpy(target,src);
     printf("%c\n",target); 

    return 0;
}

InformationsquelleAutor user20842454566 | 2015-02-23

9

Brauchen Sie nicht. Zweites argument von strcpy() werden muss nul beendet, und die ersten passen muss die Anzahl der Zeichen in source + die nul terminator.

Die Fehler im code sind:
1. Sind Sie mit sizeof operator in falscher Weise, und Sie überschreiben die src Zeiger zuweisen von Speicher wieder auf.
  
  Um die Länge der Zeichenfolge, die Sie brauchen strlen() und Sie brauchen nicht zu rufen malloc() auf jeden Zeiger.
  
  Sind Sie immer Müll Wert, denn Sie sind das kopieren von nicht initialisierten Daten seit src Punkte auf einer neu zugeteilten Raum, weil der
```
src = malloc(sizeof(char));
```
  sollten Sie nicht tun.
2. sizeof(char) == 1 per definition, so sind Sie zuweisen von Speicherplatz für nur 1 byte, was, wenn es ein Gültiger C-string, sein '\0' denn es ist Platz für genau 1 Zeichen.
3. Den richtigen printf() Bezeichner für ein string ist "%s" Sie sind mit "%c" was für ein Charakter.
Den richtigen Weg, es zu tun ist
```
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
    char       *target;
    const char *src;

    src    = "Test"; /* point to a static string literal */
    target = malloc(1 + strlen(src)); /* allocate space for the copy of the string */
    if (target == NULL) /* check that nothing special happened to prevent tragedy  */
        return -1;

    strcpy(target, src);
    printf("%s\n", target);
    /* don't forget to free the malloced pointer */
    free(target);

    return 0;
}
```
- Aber ich bekomme Müll als Ausgabe.
- Noch Müll als Ausgabe auf meinem compiler. Auch auf ideone ist die Ausgabe leer: ideone.com/duBdgX
- Never mind, du hast gerade editiert es wieder. Vielen Dank für den Einblick!
- ja, der code an der ideone hatte die falsche printf() Planer.
InformationsquelleAutor Iharob Al Asimi
2

In Ihrem code
```
strcpy(target,src);
```
src ist nicht null-terminiert ist. Dies ruft ein Undefiniertes Verhalten.

Auch mit Hilfe malloc(sizeof(char)); du bist allokierung von Speicher für nur eine einzige char element. die wahrscheinlich Sie nicht wollen.

Weiter, als pro die Mann Seite von strcpy(), (Hervorhebung von mir)

Den strcpy() Funktion kopiert die Zeichenfolge verweist src, einschließlich des abschließenden null-byte ( '\0' ), um den Puffer auf dest. Die Zeichenketten dürfen sich nicht überlappen, und der Ziel-string dest muss groß genug sein, erhalten Sie die Kopie.

so, solange
1. Ihre Quelle ist eine richtige null-terminiertes char-array (string)
2. Ziel ist, dass genügend Speicher halten die containts der Quelle
du bist gut zu gehen. Also, Sie haben zu
1. null-beenden der src array.
2. genügend Speicher, um target so dass Sie halten Sie die enthalten src.
Abschließend noch zu erwähnen, sobald Sie verwendet habe, einen string, Sie sollen die %s Formatbezeichner mit printf() zum drucken der string.
- vielen Dank für den edit. 🙂
- Keine not 🙂
InformationsquelleAutor Sourav Ghosh
1
```
man strcpy
```
BESCHREIBUNG

Die strcpy () - Funktion kopiert die Zeichenfolge verweist src, einschließlich des abschließenden null-byte ('\0'), um den Puffer auf dest.

So dass Sie nicht haben, hinzufügen von null-terminate-byte, wenn SRK es bereits.

BUGS

Wenn der Ziel-string von strcpy() nicht groß genug ist, dann noch etwas passieren könnte.

Also :
```
char *src = "Test"; // 4 chars + '\0'
target = malloc(sizeof(char)); //Space for 1 char
 strcpy(target,src); //Woops !
```
InformationsquelleAutor Coconop
1
```
target = malloc(10);
```
Haben Speicher für den string und ein nul-terminator. Ich verstehe nicht, warum Sie allokierung von Speicher für src wie ich sehe sind Sie mit einem string-literal. Nur genügend Speicher für Ziel-und tun strcpy() stellen Sie sicher, dass Sie nicht schreiben array out of bound".

Der richtige Weg wäre, um
```
target = malloc((strlen(src) + 1));
```
Machen Sie eine Notiz, wenn Sie das tun
```
char *src = "Test";
```
Den string "Test" ist gespeichert in einem nur-lese-Position und die Adresse von diesem Standort zurückgegeben src. So Ihr string ist schon im Speicher und müssen keine Speicher wieder auf, die Sie versuchen zu tun, und Sie tun es zu Unrecht. So loszuwerden malloc() für src

InformationsquelleAutor Gopi
1

Antworten bisher angesprochen haben, die Fehler in Ihren code und Ihre scheinbare Missverständnis, anstatt Ihre Frage. Zeiger auf Speicher, können indiziert werden, genauso wie arrays, so gegeben:
```
char *target = malloc( 10 ) ;
```
Kann man Elemente so:
```
target[0] = '\0' ;
```
InformationsquelleAutor Clifford

Sourav Ghosh s Antwort ist richtig, aber für diesen speziellen Fall sollten Sie strdup() wie es behandelt sowohl Speicher-Allokation und kopieren für Sie:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(void)
{
    const char *src = "Test";   //You should make this const
    char *target = strdup(src); //Duplicate             
    if (target == NULL) {       //Check
        return EXIT_FAILURE;
    }
    printf("%s\n", target);
    return EXIT_SUCCESS;
}

InformationsquelleAutor Marek Vavrusa

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.