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

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

 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\u chunk（）：无效指针：

错误，程序崩溃

我怎样才能解决这个问题

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

根据Steen的回答，我意识到问题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);

但输出总是：

---

，

函数适用于参数中有空格和无空格的情况

您必须使用

if（parsedData！=NULL）

来保护您的

free（parsedData）

，否则您将在第一次传递时释放空指针

我会沿着这条路线尝试一些东西：

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

const char*const findSubStr（char*psearchtr，char*pStrStart，char*pStrEnd）
{
//验证参数
如果（！psearchtr）返回0；
如果（！pStrStart）返回0；
如果（！pStrEnd）返回0；
if（pStrEnd对我来说很好
free（parsedData）；
在代码中的位置不正确。这适用于捕获此返回缓冲区的位置。您不应该在该函数中接触全局变量。只返回局部指针变量的值（分配的内存在堆中，因此将超出函数范围）。实际上，您根本不应该拥有全局变量，但关键是，将处理指针的责任转移到调用方。删除对
malloc（）
结果的强制转换，启用所有警告（
-Wall-Wextra-pedantic
用于gcc）和重新编译。修复代码，直到编译器不再发出警告。在再次分配内存之前，free（parsedData）被放置在那里以释放后续函数调用上的指针。我现在正试图消除所有警告。C标准显式允许将
NULL
传递给
free（）
。关于1，您是对的。感谢您抽出时间对其进行测试。我尝试了您的建议，但通过此更改，函数似乎在后续调用中返回相同的值。我想知道这是否是其他地方的问题，但我没有更改任何其他内容。很难说。您可以删除malloc，然后从固定大小的数组返回数据（char parsedData[MAX_SIZE]）。如果堆中遇到问题，这将从该函数中消除问题：）@Steen“从固定大小的数组返回数据”是什么意思？您是否忘记提到它必须是
static
，或者您是指其他内容？static是可选的，但是声明它以避免链接问题的最佳方式。我指的是这样的构造：
static char parsedData[MAX_SIZE]；
const char*const parseData（char*theString，char*start，char*end）{

我无法使用此函数。它总是返回null。总是在if（pStrEnd）处返回检查

if（pStrEnd
 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                        
}