Question

我正在尝试编写一个函数来从uart获取字符串。它用于嵌入式系统，所以我不想使用malloc。

在调用gets_e_uart1（）之后，传递给getstring函数的指针似乎指向垃圾。我不经常使用指针，所以我确定这是一个非常愚蠢和琐碎的事情，我做错了。

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;
}

更新

我决定采用将指针传递给函数的方法。这很有效，感谢所有人提供了丰富的答案。

更新代码：

 //-------------------------------------------------------------------------
 //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

提示：ptr在调用 gets_e_uart1（）之前指向垃圾。

您需要将指针传递给指向gets_e_uart1()
的指针
编辑：除非......如果您想ptr main()指向您函数中的buffer_ ...你'我有另一个问题。 buffer_位于堆栈上，一旦函数返回就超出范围。你需要在你的函数中malloc()那个记忆。

char getstring_e_uart1(char **stringPtr_, const int SIZE_) { char *buffer_ = (char*) malloc(SIZE_ * sizeof(char)); *stringPtr_ = buffer_;

（再次编辑因为我没注意你的主循环，抱歉）

然后你必须在调用puts_uart1(ptr)之后释放它，这意味着你在那个循环中不断地进行mallocing和释放。看来你有一个固定大小的缓冲区，为什么不在main()创建它并将它传递给两个函数？

Answer 2

除了Brian的回答，我认为你在这里也有问题：

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

函数返回缓冲区后不再有效，但stringPtr_仍然指向它。您可以使buffer_ static或全局分配

Answer 3

您需要在调用getstring_e_uart1()之前构造缓冲区。写入的代码将导致函数退出时销毁buffer_变量。

我想你想要更像的东西：

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

注意：我没有完成有关重用缓冲区_的验证。

Answer 4

您不需要将缓冲区设置为静态或全局 - 您只需要让调用者分配它。这些变化微不足道：

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;

    /* ... */

指针和getstring功能

4 个答案: