Question

我可以使用以下函数在两个字符串之间获取字符串：

 char* parsedData = NULL;

 const char* const parseData(char* theString, char* start, char* end){
      if (!theString) return 0;                               
      size_t startSize = strlen(start);                
      char* startP = strstr (theString,start);        
      if(!startP)
           return 0;                           
      startP+=startSize;                              
      char* endP = strstr ((startP),end);            
      if(!endP)
           return 0;                             
      //free(parsedData);                              
      parsedData = NULL;
      parsedData = (char*) malloc((size_t)(sizeof(char)*(endP-startP)+1));       
      if (parsedData == NULL) {
           return 0;
      }     
      int dataPos=0;
      while ( startP != endP ){                       
           parsedData[dataPos++]= *startP++;
      }
      parsedData[dataPos]= '\0';                      
      return parsedData;                                     
 }

我有两个问题。

当我的字符串中没有空格时，这是有效的，但不会生成空格。当我打印字符串时，我只得到（null）。
当我取消注释free()行时，出现munmap_chunk(): invalid pointer:错误，程序崩溃。

我该如何解决这个问题？

/ ****************************************编辑1 * ********* /

根据斯蒂恩的回答，我意识到问题1是由于其他地方没有错误检查。我确认该功能可以使用和不使用空格。

/ ****************************************编辑2 * ********* /

我根据海德的建议更改了代码：

const char* const parseData(char* theString, char* start, char* end){
    char* tmpstr;
    if (!theString) return 0;        
    size_t startSize = strlen(start); 
    char* startP = strstr (theString,start);
    if(!startP) return 0; 
    startP+=startSize; 
    char* endP = strstr ((startP),end); 
    if(!endP) return 0; 
    if (parsedData != NULL){ free(parsedData);} 
    parsedData = NULL;
    parsedData = (char*) malloc((size_t)(sizeof(char)*(endP-startP)+1)); 
    if (parsedData == NULL) {
        return 0;
    }  

    int dataPos=0;
    while ( startP != endP ){ 
        parsedData[dataPos++]= *startP++;
    }
    parsedData[dataPos]= '\0'; 
    tmpstr = parsedData;
    return tmpstr; 
}

我以这种方式调用函数：

const char* const usr1 = parseData(buffer, ":", ",");
const char* const usr2 = parseData(buffer, ",", ".");
const char* const usr3 = parseData(buffer, "(", ")");

printf("%s, %s, %s\n", usr1, usr2, usr3);

但输出总是：

<usr3>, <usr3>, <usr3>

Answer 1

在参数中有和没有空格的情况下，函数都适用于我。

您必须使用free(parsedData)保护if (parsedData != NULL)，否则您将在第一次通过时释放空指针

我会沿着这条路尝试一下：

const char* const parseData(char* theString, char* start, char* end){
  #define PARSE_ELEMENT_MAX_SIZE 256
  static char parsedData[ PARSE_ELEMENT_MAX_SIZE ];

  if ( theString == NULL || start == NULL || end == NULL ) {
    return 0;        
  }
  size_t startSize = strlen(start); 
  char* startP = strstr (theString,start);
  if( startP == NULL ) {
    return 0; 
  }
  startP+= startSize; 
  char* endP = strstr (startP, end); 
  if( endP == NULL || endP - startP >= PARSE_ELEMENT_MAX_SIZE ) {
    return 0; 
  }
  memcpy( parsedData, startP, endP - startP );
  parsedData[ endP - startP ]= 0;
  return parsedData; 
}

如果要在隐含调用之间保留数据，则必须让调用者拥有缓冲区，而不是在parseData函数中分配它：

BOOL parseData(char* theString, char* start, char* end,
    char *parsedData, size_t MaxSizeOfParsedData ){

  if ( theString == NULL || start == NULL || end == NULL || parsedData == NULL ) {
    return FALSE;        
  }
  char* startP = strstr (theString,start);
  if( startP == NULL ) {
    return FALSE; 
  }
  startP+= strlen(start); 
  char* endP = strstr (startP, end); 
  if( endP == NULL || endP - startP >= MaxSizeOfParsedData ) {
    return FALSE; 
  }
  memcpy( parsedData, startP, endP - startP );
  parsedData[ endP - startP ]= 0;
  return TRUE; 
}

Answer 2

 const char* const findSubStr(char* pSearchStr, char* pStrStart, char* pStrEnd)
 {
    // validate parameters
    if (!pSearchStr) return 0;
    if (!pStrStart) return 0;
    if (!pStrEnd) return 0;
    if (pStrEnd <= pStrStart) return 0;

    int   WorkStrLen = pStrEnd - pStrStart +2; // allows for terminator byte

    // get work area so can modify original string with terminator byte
    char* pWorkStr = malloc(WorkStrLen); 
    if( NULL == pWorkStr ) return 0; // check for malloc failure

    // clear work area and copy target string 
    memset( pWorkStr, 0x00, WorkStrLen );    
    memcpy( pWorkStr, pStrStart, (WorkStrLen -1) ); // avoid overlaying term byte

    // find the search string
    char* pFoundStr = strstr( pWorkStr, pSearchStr );
    // verify string found
    if ( NULL == pFoundStr ) return 0; // search string wasn't found

    int offset = pFoundStr - pWorkStr;
    free( pWorkStr );
    return( &pStrStart[offset] );  // return ptr to found substring                        
}

C：获取包含两个字符串之间空格的字符串

2 个答案: