Question

在我的代码中：

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

void build(char *input){



// how do I get the first string "one" here from the *input pointer? and dissect the string - 'one' so that I can get each character separately 
}
int main() {
    const char *strings[] = { "one", "two", "three" };
    printf("1st string is %s\n", strings[0]);
    build(strings);
    return 0;
}

这个程序的目的是在我的构建函数中获取每个字符串，例如＆＃34; one＆＃34;，并将每个字符分开 - ＆＃39; o＆＃39; ，＆＃39; n＆＃39; ，＆＃39; e＆＃39; ，然后找到一个数字，它是ASCII码的总和111（＆＃39; o＆＃39;）+ 110（＆＃39; n＆＃39;）+ 101（＆＃39; e＆＃39;） = 322。（每个字符串可能有不同的长度）

After compiling others answer I came up with this: Please let me know if this ok?


Possible Answer:

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

void build(char *input) {

    int i = 0;
    int a=0
    while (*input != '\0') {
        printf("character is %c\n", *input);
        a=a+*input;
        input++;
    }
printf("sum of ascii value of each character is %d\n",a);
    printf("------\n");

}

int main() {

    const char *strings[] = { "one", "two", "three" };

    int i = 0;
    for (i = 0; i < sizeof strings / sizeof *strings; i++)
        build(strings[i]);

    return 0;
}

Answer 1

strings实际上是一个指向char的指针。因此，使用strings参数调用build（）非常错误。

这里有很多错误：

作为指向char的指针，您需要两个取消引用操作来访问字符。 *strings[0]（以及string[0][0]和**strings）是第一个字符串的第一个字符。
build()函数需要指向char的指针。如果您计划传递build()字符串，这听起来像你想要的那样就没问题了。也许？但是在构建函数中，您正在尝试打印指针的值。但如果这就是你的目标，那也没关系。

将数组中的字符串传递给函数很容易！你这样做：

build(strings[0]);

数组索引提供一级解除引用，因此build（）仍然获得char *。在build（）中，您可以非常简单地访问字符串的每个字符，如* input或input [0]。

绝对，无论何时处理字符串，都要尽快计算长度。 build()不应该计算传递给它的字符串的长度。

Answer 2

首先，您的参数类型需要在调用方和被调用方都匹配;你不这样做。您传递的const char*数组在表达为参数时会转换为指向第一个元素的指针。由于元素为const char *，因此转化结果为const char **。但是你的功能期待char *。

二。如果您将const char*传递给函数，build函数的形式参数声明应该匹配。 char *可以传递给需要const char*的函数;情况恰恰相反。此外，我认为没有理由传递非const参数，因为该函数应该没有倾向来修改该指针所寻址的数据。

接下来，如果你计算一些ascii值的积累，你需要一个放置积累的地方，同样重要的是一个返回它的机制。函数返回结果就足够了。

最后，将所有这些移动到它自己的函数（循环;而不是数组）是直截了当的。最终结果如下：

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

unsigned int build(const char *s)
{
    unsigned int res = 0;
    for (; *s; res += (unsigned int)*s++);
    return res;
}

void build_all(const char *strings[], size_t N)
{
    for (size_t i=0; i<N; ++i)
    {
        unsigned int res = build(strings[i]);
        printf("input[%zu] = %s, %u\n", i, strings[i], res);
    }
}

int main()
{
    const char *strings[] = { "one", "two", "three" };
    build_all(strings, sizeof strings/sizeof *strings);
    return 0;
}

<强>输出

input[0] = one, 322
input[1] = two, 346
input[2] = three, 536

祝你好运。

Answer 3

希望这是你所期望的

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

void build(char *input){
int a=0,i;
for(i=0;i<strlen(input);i++)
{
   a=a+input[i];
   printf("%c %d \n ",input[i],input[i]);
}
printf("\n value of a:%d",a);

}
int main() {
int i;
const char *strings[] = { "one", "two", "three"};

for(i=0;i<sizeof(strings)/sizeof(strings[i]);i++)
build(strings[i]);
return 0;
}

Answer 4

这将完全取决于您希望进行处理的位置以及您希望build做什么。如果您希望build接受单个字符串（char *），那么您正在接近问题。如果像其他人指出的那样，您希望一次将所有字符串传递给build，那么您需要调整build参数列表以接受char**。

要继续build接受单个字符串，您需要发送每个字符串以一次构建一个字符串。进入build后，您可以选择使用索引（例如input到input[0]）访问input[length-1]中的每个字符，也可以使用可以增加到的简单字符指针通过input内的每个位置（例如char *p = input;，然后*p++访问每个角色）。

有许多方法可以做到这一点，这里有一个相对简单的例子，它使用一个字符指针来向下走输入字符串：

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

void build (const char *input) 
{
    if (!input || *input == 0) return;

    char *p = (char *)input;
    size_t i = 0;

    printf ("\n  %s (%s):\n\n", __func__, input);

    while (*p)
    {
        printf ("    input[%2zu]:  %c\n", i, *p);
        p++,i++;
    }
}

int main() {

    const char *strings[] = { "one", "two", "three" };

    size_t i = 0;

    for (i = 0; i < sizeof strings / sizeof *strings; i++)
        build (strings[i]);

    return 0;
}

<强>输出

$ ./bin/str2build

  build (one):

    input[ 0]:  o
    input[ 1]:  n
    input[ 2]:  e

  build (two):

    input[ 0]:  t
    input[ 1]:  w
    input[ 2]:  o

  build (three):

    input[ 0]:  t
    input[ 1]:  h
    input[ 2]:  r
    input[ 3]:  e
    input[ 4]:  e

将字符串引用传递给函数

4 个答案: