Pointers et fonction getstring

Question

J'essaye d'écrire une fonction pour obtenir une chaîne de uart. C'est pour un système embarqué donc je ne veux pas utiliser malloc.

Le pointeur transmis à la fonction getstring semble pointer vers un vidage après l'appel de gets_e_uart1(). Je n'utilise pas de pointeurs trop souvent, donc je suis sûr que c'est quelque chose de vraiment stupide et trivial que je fais mal.

int main() 
    { 
     char *ptr = 0; 
     while(1) 
     { 

     gets_e_uart1(ptr, 100); 
     puts_uart1(ptr); 

    } 
     return 0; 
}*end main*/ 

//------------------------------------------------------------------------- 
//gets a string and echos it 
//returns 0 if there is no error 

char getstring_e_uart1(char *stringPtr_, const int SIZE_) 

{ 

char buffer_[SIZE_]; 
stringPtr_ = buffer_; 
int start_ = 0, end_ = SIZE_ - 1; 
char errorflag = 0; 

/*keep geting chars until newline char recieved*/ 
while((buffer_[start_++] = getchar_uart1())!= 0x0D) 
{  
    putchar_uart1(buffer_[start_]);//echo it 

    /*check for end of buffer 
    wraparound if neccesary*/ 
    if(start_ == end_) 
    { 
     start_ = 0; 
     errorflag = 1; 
    } 
} 
putchar_uart1('\n'); 
putchar_uart1('\r'); 

/*check for end of buffer 
wraparound if neccesary*/ 
if(start_ == end_) 
{ 
    buffer_[0] = '\0'; 
    errorflag = 1; 
} 
else 
{ 
    buffer_[start_++] = '\0'; 
} 
return errorflag; 
} 

Mise à jour:

j'ai décidé d'aller à l'approche de passer un pointeur un tableau à la fonction. Cela fonctionne bien, merci à tous pour les réponses informatives.

code Mise à jour:

//------------------------------------------------------------------------- 
//argument 1 should be a pointer to an array, 
//and the second argument should be the size of the array 
//gets a string and echos it 
//returns 0 if there is no error 
char getstring_e_uart1(char *stringPtr_, const int SIZE_) 
{ 

    char *startPtr_ = stringPtr_; 
    char *endPtr_ = startPtr_ + (SIZE_ - 1); 
    char errorflag = 0; 

    /*keep geting chars until newline char recieved*/ 
    while((*stringPtr_ = getchar_uart1())!= 0x0D) 
    {  
     putchar_uart1(*stringPtr_);//echo it 
     stringPtr_++; 

     /*check for end of buffer 
     wraparound if neccesary*/ 
     if(stringPtr_ == endPtr_) 
     { 
      stringPtr_ = startPtr_; 
      errorflag = 1; 
     } 
    } 
    putchar_uart1('\n'); 
    putchar_uart1('\r'); 

    /*check for end of buffer 
    wraparound if neccesary*/ 
    if(stringPtr_ == endPtr_) 
    { 
     stringPtr_ = startPtr_; 
     *stringPtr_ = '\0'; 
     errorflag = 1; 
    } 
    else 
    { 
     *stringPtr_ = '\0'; 
    } 
    return errorflag; 
} 

Answer 1

Astuce: ptr pointe vers ordures avant gets_e_uart1() est appelée.

Vous devez passer un pointeur à votre pointeur sur gets_e_uart1()

EDIT: ... Sauf si vous essayez d'avoir ptr en main() points au buffer_ dans votre fonction ... vous avez eu un autre problème. buffer_ est sur la pile et est hors de portée dès que la fonction retourne. Vous auriez besoin de malloc() cette mémoire dans votre fonction.

char getstring_e_uart1(char **stringPtr_, const int SIZE_) 
{ 

    char *buffer_ = (char*) malloc(SIZE_ * sizeof(char)); 
    *stringPtr_ = buffer_; 

(édition à nouveau parce que je ne faisais pas attention à votre boucle principale, désolé)

alors vous allez devoir le libérer après avoir appelé puts_uart1(ptr) ce qui signifie que vous et en libérant constamment allouer de dans cette boucle. Il semble que vous ayez une taille fixe pour ce tampon, pourquoi ne pas le créer en main() et le passer dans les deux fonctions?

Answer 2

En plus de la réponse de Brian Je pense que vous avez aussi un problème:

char getstring_e_uart1(char *stringPtr_, const int SIZE_) 
{ 
char buffer_[SIZE_]; 
stringPtr_ = buffer_; 

après la fonction retourne tampon n'est plus valide mais stringPtr_ serait encore pointez-y. Vous pourriez faire buffer_ statique ou l'affecter globalement

Answer 3

Vous devez construire le tampon avant d'appeler getstring_e_uart1(). Le code tel que écrit provoquera la destruction de la variable buffer_ quand la fonction se termine.

Je pense que vous voulez quelque chose comme:

char buffer_[SIZE_]; 
while(1) { 
    char* ptr = buffer_; 
    gets_e_uart1(ptr, sizeof(buffer_)); 
    puts_uart1(ptr); 
} 

Note: Je l'ai fait aucune vérification en ce qui concerne la réutilisation de la buffer_ variable.

Answer 4

Vous n'avez pas besoin de rendre le tampon statique ou global - il vous suffit d'avoir l'appelant pour l'allouer.Les changements sont triviaux:

int main() 
{ 
    while(1) 
    { 
     char buffer[100] = { 0 }; 

     gets_e_uart1(buffer, sizeof buffer); 
     puts_uart1(buffer); 

    } 
    return 0; 
} 

//------------------------------------------------------------------------- 
//gets a string and echos it 
//returns 0 if there is no error 

char getstring_e_uart1(char *buffer_, const int SIZE_) 
{ 
    int start_ = 0, end_ = SIZE_ - 1; 
    char errorflag = 0; 

    /* ... */