C 如何传递指向字符串的指针、指向子字符串的指针以及返回其他内容？

我在一个空间极其有限的MCU上，不知何故我失去了C语言中的参考。我想要这样的格式：

int commandsubstring(char *stringaddress,char *substringaddress);

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

int main(void)
{
  const char * cmd = "MEASure:VOLTage:DC?";
  puts(cmd);
  const char * subcmd = strchr(cmd, ':');
  if (NULL == subcmd || !*(++subcmd))
  {
    fprintf(stderr, "No sub-command found.\n");
  }
  else
  {
    puts(subcmd);
  }
}

然而，我在ASM中执行了这个例程，因为我在C中遇到了一些问题，我只是想完成它。既然已经完成了，我想把它修好。该函数所做的是读取命令。我采用“MEASure:VOLTage:DC？”的格式，然后递归返回命令。在我的示例中，希望返回子字符串的地址

 MEASure:VOLTage:DC?
 ^       ^ 

我希望能够做到以下几点：

char *cmd="MEASure:VOLTage:DC?";
char *subcmd;
commandsubstring(cmd, subcmd);
printf("%s\n", cmd);
printf("%s\n", subcmd);

然后得到结果

 MEASure:VOLTage:DC?
 VOLTage:DC?

我不确定为什么，但我在这个过程中的某个地方丢失了指针。在代码的其余部分，我只返回结构，但由于这一特定部分是递归的，我想尝试一些我认为更安全的方法，但我似乎无法获得正确的C，这只是一个脑筋急转弯。如蒙协助，将不胜感激

编辑

---

这不是关于标记化的问题，只是正确返回同一字符串中不同位置的正确方法。

查看您提供的声明和使用示例，我想说您需要一个指向指针的指针作为第二个参数。您拥有的是指向char的指针

您的行为看起来很像一种未定义的行为：

/* Takes two pointer by value */
int commandsubstring(char *stringaddress,char *substringaddress);

void foo(void) 
{
   char *cmd="MEASure:VOLTage:DC?";
   char *subcmd;                  /* an uninitialized variable, could be anything */
   commandsubstring(cmd, subcmd); /* you pass an uninitilized variable in */
   printf("%s\n", cmd);
   printf("%s\n", subcmd);        /* you use an uninitialized variable. Nothing has changed it since it was declared. */
}

您对“正确返回同一字符串中不同位置的正确方法”的请求听起来像是“正确返回同一字符串中字符指针的方法”。有两种方法：可以使用返回值，也可以使用OUT参数

假设它不是

char*

，而是您希望从某个函数中得到

int

。以下是“int”选项：

---

看看您提供的声明和用法示例，我想说您需要一个指向指针的指针作为第二个参数。您拥有的是指向char的指针

您的行为看起来很像一种未定义的行为：

/* Takes two pointer by value */
int commandsubstring(char *stringaddress,char *substringaddress);

void foo(void) 
{
   char *cmd="MEASure:VOLTage:DC?";
   char *subcmd;                  /* an uninitialized variable, could be anything */
   commandsubstring(cmd, subcmd); /* you pass an uninitilized variable in */
   printf("%s\n", cmd);
   printf("%s\n", subcmd);        /* you use an uninitialized variable. Nothing has changed it since it was declared. */
}

您对“正确返回同一字符串中不同位置的正确方法”的请求听起来像是“正确返回同一字符串中字符指针的方法”。有两种方法：可以使用返回值，也可以使用OUT参数

假设它不是

char*

，而是您希望从某个函数中得到

int

。以下是“int”选项：

执行此操作时：

char *cmd="MEASure:VOLTage:DC?";
char *subcmd;
commandsubstring(cmd, subcmd);

您正在将

subcmd

的值传递给函数。在函数内部，它可能为命名参数赋值，而命名参数不会更改调用函数中的变量

最干净的处理方法是删除第二个参数并返回有问题的指针，将其分配给

subcmd

：

char *commandsubstring(char *stringaddress);

...

subcmd = commandsubstring(cmd);

执行此操作时：

char *cmd="MEASure:VOLTage:DC?";
char *subcmd;
commandsubstring(cmd, subcmd);

您正在将

subcmd

的值传递给函数。在函数内部，它可能为命名参数赋值，而命名参数不会更改调用函数中的变量

最干净的处理方法是删除第二个参数并返回有问题的指针，将其分配给

subcmd

：

char *commandsubstring(char *stringaddress);

...

subcmd = commandsubstring(cmd);

---

也许这个例子会有帮助：

#include <stdio.h>

int commandsubstring(char *stringaddress,char **substringaddress)
{
    char * ptr = stringaddress;
    while (ptr!=0) {
        if ((*ptr)==':') { 
            *substringaddress = ptr+1; 
            break;
        }
        ptr++;
    }
    return 0;
}

int main()
{
    char *cmd="MEASure:VOLTage:DC?";
    char *subcmd;
    commandsubstring(cmd, &subcmd);
    printf("%s\n", cmd);
    printf("%s\n", subcmd);

    return 0;
}

#包括
int commandsubstring（char*stringaddress，char**substringaddress）
{
char*ptr=stringaddress；
while（ptr！=0）{
如果（（*ptr）='：'）{
*子字符串地址=ptr+1；
打破
}
ptr++；
}
返回0；
}
int main（）
{
char*cmd=“测量：电压：直流？”；
char*subcmd；
命令子字符串（cmd和subcmd）；
printf（“%s\n”，cmd）；
printf（“%s\n”，subcmd）；
返回0；
}

也许这个例子会有帮助：

#include <stdio.h>

int commandsubstring(char *stringaddress,char **substringaddress)
{
    char * ptr = stringaddress;
    while (ptr!=0) {
        if ((*ptr)==':') { 
            *substringaddress = ptr+1; 
            break;
        }
        ptr++;
    }
    return 0;
}

int main()
{
    char *cmd="MEASure:VOLTage:DC?";
    char *subcmd;
    commandsubstring(cmd, &subcmd);
    printf("%s\n", cmd);
    printf("%s\n", subcmd);

    return 0;
}

#包括
int commandsubstring（char*stringaddress，char**substringaddress）
{
char*ptr=stringaddress；
while（ptr！=0）{
如果（（*ptr）='：'）{
*子字符串地址=ptr+1；
打破
}
ptr++；
}
返回0；
}
int main（）
{
char*cmd=“测量：电压：直流？”；
char*subcmd；
命令子字符串（cmd和subcmd）；
printf（“%s\n”，cmd）；
printf（“%s\n”，subcmd）；
返回0；
}

假设子命令由第一个

标识：

可以这样做：

int commandsubstring(char *stringaddress,char *substringaddress);

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

int main(void)
{
  const char * cmd = "MEASure:VOLTage:DC?";
  puts(cmd);
  const char * subcmd = strchr(cmd, ':');
  if (NULL == subcmd || !*(++subcmd))
  {
    fprintf(stderr, "No sub-command found.\n");
  }
  else
  {
    puts(subcmd);
  }
}

#包括
#包括
内部主（空）
{
const char*cmd=“测量：电压：DC？”；
put（cmd）；
常量char*subcmd=strchr（cmd，：'）；
if（NULL==subcmd | |！*（++subcmd））
{
fprintf（stderr，“未找到子命令。\n”）；
}
其他的
{
puts（subcmd）；
}
}

将此作为一个函数

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

const char * find_subcmd(const char * cmd)
{
  assert(NULL != cmd);

  char * subcmd = strchr(cmd, ':');
  return (NULL == subcmd || !*(++subcmd)) ?NULL :subcmd;
}

int main(void)
{
  const char * cmd = "MEASure:VOLTage:DC?";
  puts(cmd);
  const char * subcmd = find_subcmd(cmd);
  if (NULL == subcmd)
  {
    fprintf(stderr, "No sub-command found.\n");
  }
  else
  {
    puts(subcmd);
  }
}

#包括
#包括
#包括
常量字符*find_subcmd（常量字符*cmd）
{
断言（NULL！=cmd）；
char*subcmd=strchr（cmd，，：'）；
返回（NULL==subcmd | |！*（++subcmd））？NULL:subcmd；
}
内部主（空）
{
const char*cmd=“测量：电压：DC？”；
put（cmd）；
const char*subcmd=find_subcmd（cmd）；
if（NULL==subcmd）
{
fprintf（stderr，“未找到子命令。\n”）；
}
其他的
{
puts（subcmd）；
}
}

或

#包括
#包括
#包括
int find_subcmd（常量字符*cmd，字符常量**psubcmd）
{
断言（NULL！=cmd）；
断言（NULL！=psubcmd）；
char*subcmd=strchr（cmd，，：'）；
*psubcmd=（NULL==subcmd | |！*（++subcmd））？NULL:subcmd；
返回*psubcmd？0:-1；
}
内部主（空）
{
const char*cmd=“测量：电压：DC？”；
const char*subcmd=NULL；
put（cmd）；
如果（-1==find_subcmd（cmd和subcmd））
{
fprintf（stderr，“未找到子命令。\n”）；
}
其他的
{
puts（subcmd）；
}
}

---

请注意，在上述任何解决方案中，

subcmd

只是指向

cmd

所指向的内容。未复制任何数据。

假设子命令由第一个

标识：

可以这样做：

int commandsubstring(char *stringaddress,char *substringaddress);

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

int main(void)
{
  const char * cmd = "MEASure:VOLTage:DC?";
  puts(cmd);
  const char * subcmd = strchr(cmd, ':');
  if (NULL == subcmd || !*(++subcmd))
  {
    fprintf(stderr, "No sub-command found.\n");
  }
  else
  {
    puts(subcmd);
  }
}

#包括
#包括
内部主（空）
{
const char*cmd=“测量：电压：DC？”；
put（cmd）；
常量char*subcmd=strchr（cmd，：'）；
if（NULL==subcmd | |！*（++subcmd））
{
fprintf（标准数据集）