C 预定义/指定字符[]的大小、命名约定、轻松复制结构和使用符号获取函数地址

如何找到包含字符串的预定义char[]变量的大小？ sizeof够了吗？ 我不想使用strlen，因为字符串中可能会出现“\0”字符，并且出于优化原因。 例如：char str[]=Hello\x45\x10\x00 World

当标识符中有首字母时，您会怎么做？例如，GetURLParameters。 我想添加一个下划线：GetURL\u参数。这种情况的惯例是什么

如何轻松地将值复制到由变量/指针指向的结构的字段中？ 例如，我想做一些类似的事情：

struct {
int         bar1;
char*       bar2;
callback    bar3;
} *foo = NULL;
foo = malloc(sizeof *foo);
*foo = { 0, "Hello World!", myFunc };   // This is wrong

为什么程序员有时会使用符号将函数地址分配给函数指针？例如：

void (*callback)(void);
callback = &myFunc;

对不起，我不能很好地编辑我的帖子。当我编辑和向您显示时，它看起来不同

如果是char[]而不是char*，sizeof将为您提供数组大小，对于以nul结尾的字符串，数组大小为strlen+1。如果您需要广泛地使用字符串，特别是其中可能有“0”字符的字符串和/或可能没有NUL终止的字符串，则应该考虑使用字符串库。这会让你的生活更轻松。 你要什么都行。我个人从不在标识符中使用大写字母，因为我认为混合案例标识符很难看。没有命名标识符的约定，只有一些人喜欢的约定。使用你和你的团队认为最好的东西。 您可以这样做：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

我的fu标准让我不及格，所以我不知道为什么这样做，或者即使它确实有效，但我相信它确实有效。如果不起作用，只需创建一个init函数，将所有字段设置为默认值

一致性为指针分配地址时，通常是必需的，即int i=5，*j=&i；因此，尽管函数指针并不是严格必需的，但有些人喜欢这样做，使所有指针赋值看起来都一样。这只是美学。 然而，在未来，这些问题中的大多数是相互无关的。你不应该把四个不相关的问题组合成一个巨大的怪物问题，而是分开问。这会让你花更多的时间来做每一件事，每一件事都会更加连贯一致，这样我们就能给你更好的答案，你也会学到更多

如果是char[]而不是char*，sizeof将为您提供数组大小，对于以nul结尾的字符串，数组大小为strlen+1。如果您需要广泛地使用字符串，特别是其中可能有“0”字符的字符串和/或可能没有NUL终止的字符串，则应该考虑使用字符串库。这会让你的生活更轻松。 你要什么都行。我个人从不在标识符中使用大写字母，因为我认为混合案例标识符很难看。没有命名标识符的约定，只有一些人喜欢的约定。使用你和你的团队认为最好的东西。 您可以这样做：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

我的fu标准让我不及格，所以我不知道为什么这样做，或者即使它确实有效，但我相信它确实有效。如果不起作用，只需创建一个init函数，将所有字段设置为默认值

一致性为指针分配地址时，通常是必需的，即int i=5，*j=&i；因此，尽管函数指针并不是严格必需的，但有些人喜欢这样做，使所有指针赋值看起来都一样。这只是美学。 然而，在未来，这些问题中的大多数是相互无关的。你不应该把四个不相关的问题组合成一个巨大的怪物问题，而是分开问。这会让你花更多的时间来做每一件事，每一件事都会更加连贯一致，这样我们就能给你更好的答案，你也会学到更多

sizeof就足够了

品味问题。我根本不在标识符中使用大写字母，除非它们是全局常量

您可以这样做：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

如果myFunc是一个函数，则使其显式（尽管不是必需的）

sizeof就足够了

品味问题。我根本不在标识符中使用大写字母，除非它们是全局常量

您可以这样做：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

如果myFunc是一个函数，则使其显式（尽管不是必需的）

---

如果要将值从一个结构复制到另一个结构，可以执行以下操作：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

输出：

---------- Capture Output ----------
> "c:\windows\system32\cmd.exe" /c c:\temp\temp.exe
foo->bar1 = 10, foo->bar2 = hi
foo2->bar1 = 10, foo2->bar2 = hi

> Terminated with exit code 0.

---

如果要将值从一个结构复制到另一个结构，可以执行以下操作：

struct s {
    int         bar1;
    char*       bar2;
    callback    bar3;
};
struct s *foo = NULL;
static struct s default = { 0, "Hello, world!", myFunc };
foo = malloc(sizeof *foo);
*foo = s;

struct foo {
    int   a;
    char  *b;
} bar;

bar = (struct foo){0, "Hello"};

typedef struct {
    int         bar1;
    char*       bar2;
    int (*callback)(int);
} mystruct;

char str[] = "Hello \x45\x10\x00 World!";

int main() { 
  mystruct* foo = (mystruct*)malloc(sizeof(mystruct));
  mystruct* foo2 = (mystruct*)malloc(sizeof(mystruct));
  foo->bar1 = 10;
  foo->bar2 = "hi";

  printf("foo->bar1 = %d, foo->bar2 = %s\n",foo->bar1,foo->bar2);

  memcpy(foo2,foo,sizeof(*foo));

  printf("foo2->bar1 = %d, foo2->bar2 = %s\n",foo2->bar1,foo2->bar2);

  free(foo);
  free(foo2);
  return 0;
}

输出：

---------- Capture Output ----------
> "c:\windows\system32\cmd.exe" /c c:\temp\temp.exe
foo->bar1 = 10, foo->bar2 = hi
foo2->bar1 = 10, foo2->bar2 = hi

> Terminated with exit code 0.

---

2我使用c建议

如果是两个首字母，则为所有大写字母，否则仅为首字母大写字母。例子

---

DSPointer、FtpServer、getHDSeekTime、sendsmtmessage我使用c建议

如果是两个首字母，则为所有大写字母，否则仅为首字母大写字母。例子

DSPointer、FtpServer、getHDSeekTime、sendsmtmessage

通常，数组中的元素数由表达式sizeof arr/sizeof arr[0]或sizeof arr/sizeof*arr给出。 sizeof运算符返回数组的大小（以字节为单位），而不是元素数，因此必须将数组中的字节数除以单个元素中的字节数。但是，由于sizeof char==1，您可以通过sizeof arr获得char数组中的元素数。请注意，表达式arr必须是数组类型，而不是指针类型。例如，如果arr作为类型为T arr[]的函数参数传递，则它是指针类型，sizeof将为您提供指针中的字节数，而不是数组本身

有许多约定，没有一个比其他约定更好。你选择哪种习惯并不重要，只要你始终如一地使用它

C89不支持这样的复合文本。C99是的，它应该看起来像*foo=struct s{0，你好，World，myfunc}；假设将标记s添加到结构定义中。然而，我对C99的特性不太熟悉，所以不要把它当作福音

习惯。实际上，它什么也不做。不管怎样，在通常的转换规则下，函数指示符被隐式转换为指向函数的指针

通常，数组中的元素数由表达式sizeof arr/sizeof arr[0]或sizeof arr/sizeof*arr给出。sizeof运算符返回以字节为单位的数组大小，而不是元素数，因此必须将数组中的字节数除以单个元素中的字节数。但是，由于sizeof char==1，您可以通过sizeof arr获得char数组中的元素数。请注意，表达式arr必须是数组类型，而不是指针类型。例如，如果arr作为类型为T arr[]的函数参数传递，则它是指针类型，sizeof将为您提供指针中的字节数，而不是数组本身

有许多约定，没有一个比其他约定更好。你选择哪种习惯并不重要，只要你始终如一地使用它

C89不支持这样的复合文本。C99是的，它应该看起来像*foo=struct s{0，你好，World，myfunc}；假设将标记s添加到结构定义中。然而，我对C99的特性不太熟悉，所以不要把它当作福音

习惯。实际上，它什么也不做。不管怎样，在通常的转换规则下，函数指示符被隐式转换为指向函数的指针

---

对不起，我们不是来做别人的家务的，这不是家庭作业，真的。我不明白你为什么这么想。无论如何谢谢。对不起，我们不是来做别人的家务的。这不是家庭作业，真的。我不明白你为什么这么想。不管怎样，谢谢。好的，谢谢，我是新来的，所以我不知道所有的不成文规则。我认为连续地提出太多的问题是自私的或是别的什么。@chrislutz-这段代码不适合我。我使用的是与cygwin捆绑在一起的g++版本，不确定确切的版本号。我想你需要对malloc进行强制转换，如果我错了，请随意更正。@dcp：为什么你在C代码上使用g++而不是gcc？Maloc不需要在C中强制转换。MulalCalm的争论可以继续进行，但总而言之：如果需要人们用C++编译器编译它，你就没有选择，必须进行转换。如果您不需要，您可以根据需要进行强制转换，但是如果您不需要，a您将收到警告，如果您忘记在强制转换中包含，它将自动失败，因为malloc已获得一个隐式签名，b如果稍后类型更改，例如，从char*到wchar\u t*您不需要返回并更改所有类型转换，这与使用sizeof*foo而不是sizeofstruct foo的原因相同。第二个是最引人注目的。请注意，sizeof将给出数组的大小（以字节为单位），而不是元素的数量。对于char数组，这是相同的，但对于其他类型，情况并非如此。对于类型为T的数组，其中T不是char，元素的数量由sizeof arr/sizeof arr[0]给出。好的，谢谢，我是新来的，所以我不知道所有不成文的规则。我认为连续地提出太多的问题是自私的或是别的什么。@chrislutz-这段代码不适合我。我使用的是与cygwin捆绑在一起的g++版本，不确定确切的版本号。我想你需要对malloc进行强制转换，如果我错了，请随意更正。@dcp：为什么你在C代码上使用g++而不是gcc？Maloc不需要在C中强制转换。MulalCalm的争论可以继续进行，但总而言之：如果需要人们用C++编译器编译它，你就没有选择，必须进行转换。如果您不需要，您可以根据需要进行强制转换，但是如果您不需要，a您将收到警告，如果您忘记在强制转换中包含，它将自动失败，因为malloc已获得一个隐式签名，b如果稍后类型更改，例如，从char*到wchar\u t*您不需要返回并更改所有类型转换，这与使用sizeof*foo而不是sizeofstruct foo的原因相同。第二个是最重要的 请注意，sizeof将给出数组的大小（以字节为单位），而不是元素数。对于char数组，这是相同的，但对于其他类型，情况并非如此。对于类型为T的数组，其中T不是char，元素数由sizeof arr/sizeof arr[0]给出。