由单线引起的堆缓冲区溢出

Question

目前正在尝试通过做一些LeetCode问题来处理我的C（非常新的）。我对这个问题感到困惑，因为它给了我堆的缓冲区溢出，但仅由于一行。 drigens（）被调用并传递了字符串命令其中1＆lt; = command.length＆lt; = 100，将由“ g” ，“（）”和/或“（al）”在某些顺序上，没有其他字符出现。

char * interpret(char * command){
    
    char * ret = malloc(sizeof(char) * 100);
    int counter = 0;
    for(int i = 0; i < sizeof(command) - 1; i++)
    {
        if(command[i] == 'G')
        {
            ret[counter] = 'G';
            counter ++;
        }
        else if(command[i] == '(')
        {
            if (command[i + 1] == ')')
            {
                ret[counter] = 'o';
                counter ++;
            }
            else
            {
                //ret[counter] = 'a'; ***********
                ret[counter + 1] = 'l';
                counter += 2;
            }
        }
        ret[counter] = '\0';
    }
    return realloc(ret, counter * sizeof(char));
}

如果标明的行是未注册的，则整个程序在Leetcode中崩溃，但在VSCODE上工作正常并返回正确的解决方案。我会感谢任何帮助，我敢肯定这是我缺少的小东西。谢谢。

eta：这是所讨论的leetcode问题

Answer 1

参数命令具有指针类型char *。

因此，应用于指针的操作员sizeof可产生指针的大小，而不是尖字符串的长度，

for(int i = 0; i < sizeof(command) - 1; i++)

您可以写入

for( size_t i = 0; command[i] != '\0'; i++)

尖头的长度，也不清楚为什么使用魔术数字100

char * ret = malloc(sizeof(char) * 100);

您可以首先计数结果字符，然后分配适当大小的数组并填充它。

此外，由于此语句

    ret[counter] = '\0';

（这也不清楚为什么在for循环中）您需要使用counter + 1字符而不是counter字符分配一个数组 采用

return realloc(ret, counter * sizeof(char));

如下演示程序所示，

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

char * interpret( const char *command )
{
    size_t n = 0;

    for ( size_t i = 0; command[i] != '\0';  )
    {
        if ( command[i] == 'G' )
        {
            ++n;
            ++i;
        }
        else if ( strncmp( command + i, "()", 2 ) == 0 )
        {
            ++n;
            i += 2;
        }
        else if (  strncmp( command + i, "(al)", 4 ) == 0 )
        {
            n += 2;
            i += 4;
        }
        else
        {
            ++i;
        }
    }

    char *result = malloc( n + 1 );

    if ( result != NULL )
    {
        n = 0;

        for ( size_t i = 0; command[i] != '\0';  )
        {
            if ( command[i] == 'G' )
            {
                result[n++] = 'G';
                ++i;
            }
            else if ( strncmp( command + i, "()", 2 ) == 0 )
            {
                result[n++] = 'o';
                i += 2;
            }
            else if (  strncmp( command + i, "(al)", 4 ) == 0 )
            {
                result[n++] = 'a';
                result[n++] = 'l';
                i += 4;
            }
            else
            {
                ++i;
            }
        }

        result[n] = '\0';
    }

    return result;
}

int main( void )
{
    char *s = interpret( "G()(al)" );
    if ( s ) puts( s );
    free( s );

    s = interpret( "(al)G(al)()()G" );
    if ( s ) puts( s );
    free( s );
}

直接的方法可以看起来以下方式。程序输出是

Goal
alGalooG

Answer 2

将命令的大小传递到解释。

在C中，当您将字符串传递给函数时，您实际上并没有传递完整的字符串，而是将指针传递给字符串中的第一个元素。当您进行大小（命令）时，这将成为一个问题，因为您只是获得指针的大小而不是完整的字符串。如果您尝试按照问题中完成的此字符串进行循环，则如果您的字符串长于sizeof（char*），或字符串短于sizeof（char*）。通常，您不应在指针上使用尺寸。

要修复您的代码，请在您传递给命令的字符串上使用strlen，并执行与此类似的操作：

char * interpret(char * command, int size){

char * ret = malloc(sizeof(char) * 100);
int counter = 0;
for(int i = 0; i < size; i++) 
{ ...