在C中迭代输入字符参数？

我试图在C中迭代输入参数，并将其存储在指向char的指针中，如下所示：

constchar*page=argv[1]

现在，参数将是一个http地址，因此它可能看起来像这样：

http://host:port/folder1/folder2/file.jpg

我想要的是：解析这个字符串，并将它分离成子字符串

char host = "host"; 
char port = "port"; 
char path = "/folder1/folder2/file.jpg";
char file = "file.jpg"; 

所以我认为一个简单的循环计数斜杠的数量就可以了

int slash_cnt = 0;
int i = 0;

for (i = 0, page[i] != '\0', i++)
{ 
    if (strcmp(&page[i], "/")) 
    { 
        slash_cnt++; 
    }
}

但这不起作用

如果有人能在这里帮助我，或者甚至建议一种更好的方法来解析输入中指定的http地址并相应地将其分离，我将非常感激
 
strstr
可用于搜索分隔感兴趣部分的字符串
/
、
/
和
：
strrchr
可用于查找文件名前面的尾随
/

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

int main()
{
    char *page = "http://host:port/folder1/folder2/file.jpg";
    char *slashes = "//";
    char *slash = "/";
    char *colon = ":";
    char *start = NULL;
    char *stop = NULL;
    char *host = NULL;
    char *port = NULL;
    char *path = NULL;
    char *file = NULL;
    size_t span = 0;

    if ( ( start = strstr ( page, slashes)) == NULL) {
        fputs ( "could not find \"//\"\n", stderr);
        return 1;
    }
    start += strlen ( slashes);//move pointer so the slashes are excluded
    if ( ( stop = strstr ( start, colon)) == NULL) {
        fputs ( "could not find \":\"\n", stderr);
        return 1;
    }
    span = stop - start;
    if ( ( host = malloc ( span)) == NULL) {
        fputs ( "malloc failed\n", stderr);
        return 1;
    }
    memmove ( host, start, span);
    host[span] = '\0';

    start = stop + strlen ( colon);
    if ( ( stop = strstr ( start, slash)) == NULL) {
        fputs ( "could not find leading \"/\"\n", stderr);
        return 1;
    }
    span = stop - start;
    if ( ( port = malloc ( span)) == NULL) {
        fputs ( "malloc failed\n", stderr);
        return 1;
    }
    memmove ( port, start, span);
    port[span] = '\0';

    span = strlen ( stop) + 1;
    if ( ( path = malloc ( span)) == NULL) {
        fputs ( "malloc failed\n", stderr);
        return 1;
    }
    memmove ( path, stop, span);
    path[span] = '\0';

    if ( ( start = strrchr ( page, slash[0])) == NULL) {
        fputs ( "could not find trailing \"/\"\n", stderr);
        return 1;
    }
    start += strlen ( slash);
    span = strlen ( start) + 1;
    if ( ( file = malloc ( span)) == NULL) {
        fputs ( "malloc failed\n", stderr);
        return 1;
    }
    memmove ( file, start, span);
    file[span] = '\0';

    puts ( host);
    puts ( port);
    puts ( path);
    puts ( file);

    free ( host);
    free ( port);
    free ( path);
    free ( file);

    return 0;
}

#包括
#包括
#包括
int main（）
{
字符*页=”http://host:port/folder1/folder2/file.jpg";
字符*斜杠=“/”；
字符*斜杠=“/”；
char*colon=“：”；
char*start=NULL；
char*stop=NULL；
char*host=NULL；
char*port=NULL；
char*path=NULL；
char*file=NULL；
尺寸跨度=0；
if（（开始=strstr（第页，斜杠））==NULL）{
fputs（“找不到\“/\”\n”，stderr）；
返回1；
}
start+=strlen（斜杠）；//移动指针以排除斜杠
if（（停止=strstr（开始，冒号））==NULL）{
fputs（“找不到\”：\“\n”，stderr）；
返回1；
}
span=停止-启动；
如果（（主机=malloc（span））==NULL）{
fputs（“malloc failed\n”，stderr）；
返回1；
}
memmove（主机、启动、跨度）；
主机[span]='\0'；
开始=停止+strlen（冒号）；
如果（（停止=strstr（开始，斜杠））==NULL）{
fputs（“找不到前导\“/\”\n”，stderr）；
返回1；
}
span=停止-启动；
如果（（端口=malloc（span））==NULL）{
fputs（“malloc failed\n”，stderr）；
返回1；
}
memmove（端口、启动、跨度）；
端口[span]='\0'；
span=strlen（停止）+1；
if（（path=malloc（span））==NULL）{
fputs（“malloc failed\n”，stderr）；
返回1；
}
memmove（路径、停止、跨度）；
路径[span]='\0'；
if（（开始=strrchr（第页，斜杠[0]））==NULL）{
fputs（“找不到尾随\“/\”\n”，stderr）；
返回1；
}
开始+=strlen（斜线）；
span=strlen（开始）+1；
if（（file=malloc（span））==NULL）{
fputs（“malloc failed\n”，stderr）；
返回1；
}
memmove（文件、开始、跨度）；
文件[span]='\0'；
放置（主机）；
港口；
放置（路径）；
放置（文件）；
免费（主机）；
自由港；
自由（路径）；
免费（文件）；
返回0；
}
Well的可能副本我刚刚尝试编写一个自定义解析器，正如您所看到的，它不起作用，这就是为什么我要问这个问题：）
strcmp（）
比较字符串，而不是单个字符或字符串的一部分。RTFM.well
if（strcmp（&page[i]，“/”）
可以简化为
if（page[i]=='/'））
。你能不能让它更清楚一点，你想要这个解析器做什么？如果您想清理这些内容，可以使用
char*
数组，并通过枚举访问它们。无论如何，最好的办法是调用指针上的
strcpy
“当前位置”-找到斜杠（或字符串乞讨）的最后一个位置。@George-
strcmp（&page[i]，“/”）
并不等同于
page[i]='/'
。