标签: c-strings

我想把a转换CString成a char[].有人告诉我怎么做？

我的代码是这样的:

CString strCamIP1 = _T("");
char g_acCameraip[16][17];
strCamIP1 = theApp.GetProfileString(strSection, _T("IP1"), NULL);
g_acCameraip[0] = strCamIP1;

我真的很困惑在字符串上使用指针.感觉他们遵守不同的规则.请考虑以下代码

1. char *ptr = "apple";// perfectly valid here not when declaring afterwards like next
   
   ptr = "apple"; // shouldn't it be *ptr = "apple"
   

   Run Code Online (Sandbox Code Playgroud)

2. 也printf()表现不同-

   printf("%s", ptr) // Why should I send  the address instead of the value
   

   Run Code Online (Sandbox Code Playgroud)

3. 我还在一本书中看到了以下代码

   char str[]="Quest";
   char *p="Quest";
   
   str++; // error, constant pointer can't change
   
   *str='Z'; // works, because pointer is not constant
   
   p++; // works, because pointer is not constant
   
   *p = 'M'; // error, because string is constant
   

   Run Code Online (Sandbox Code Playgroud)

我无法理解应该暗示什么

请帮忙,我在其他地方找不到任何信息

据我了解,以下代码的工作原理如下:

char* cptr = "Hello World";

"Hello World"存在于.rodata程序记忆的部分.字符串文字"Hello World"返回一个指向字符串基址的指针,或者所谓的"数组"中第一个元素的地址,因为字符在内存中顺序排列,它将是'H'.这是我的小图,因为我可视化存储在内存中的字符串文字:

0x4 : 'H'
0x5 : 'e'
0x6 : 'l'
0x6 : 'l'
0x7 : 'o'
0x8 : ' '
0x9 : 'W'
0xa : 'o'
0xb : 'r'
0xc : 'l'
0xd : 'd'
0xe : '\0'

所以上面的声明变成:

char* cptr = 0x4;

现在cptr指向字符串文字.我只是在编写地址.

0xa1 : 0x4

现在这段代码如何工作？

char cString[] = "Hello World";

我假设在前面的情况下"Hello World"也降级为'H'和0x4的地址.

char cString[] = 0x4;

我在=初始化char数组时使用的是重载赋值运算符.据我所知,仅在C字符串的初始化时,它会将char-by-char从给定的基址开始复制到C字符串中,直到它在复制的最后一个char时命中'\ 0'.它还为所有字符分配足够的内存.因为重载运算符实际上只是函数,我认为它的内部实现类似于strcpy().

我希望有一位经验丰富的C程序员确认我对这段代码如何工作的假设.这是我对字符串文字中的字符复制到其中后的C字符串的可视化: …

我需要执行一个FFI签名：

pub unsafe extern fn f(header_size: u32, header_ptr: *mut u8) -> i32;

FFI调用程序应提供一个缓冲区header_ptr以及该缓冲区的大小header_size。预期Rust会将一个字符串填充到该缓冲区中，直到header_size，0如果成功，则返回。FFI调用程序应将字符串解释为ASCII。

给定headers: &str我要提供的内容，如何以最惯用的方式填充该缓冲区？

现在我有：

let header_bytes = slice::from_raw_parts_mut(header_ptr, header_size as usize);

if header_bytes.len() < headers.len() { return Errors::IndexOutOfBounds as i32; }

for (i, byte) in headers.as_bytes().iter().enumerate() {
    header_bytes[i] = *byte;
}

但这感觉不对。

编辑，我认为这是不完全相同的副本来这个，因为我的问题涉及到字符串，STR转换和对CStrings时IIRC有特殊的考虑。

我有几个关于字符串文字和 C 字符串的问题想问。

所以如果我有这样的东西：

char cstr[] = "c-string";

据我了解，字符串文字是在内存中创建的，带有终止空字节，例如从地址 0xA0 开始到 0xA9 结束，然后从那里返回地址和/或转换为 char [ ] 类型，然后指向地址。

那么执行此操作是合法的：

for (int i = 0; i < (sizeof(array)/sizeof(char)); ++i)
    cstr[i] = 97+i;

那么从这个意义上说，只要将字符串文字转换为 char[] 类型，就可以修改它们吗？

但是对于常规指针，我开始了解到，当它们指向内存中的字符串文字时，它们无法修改内容，因为大多数编译器在常量的某些下限地址空间中将分配的内存标记为“只读”。

char * p = "const cstring";
*p = 'A'; // illegal memory write

我想我想要理解的是为什么 char * 类型不允许像数组一样指向字符串文字并修改它们的常量？为什么字符串文字不像 char [ ] 那样被转换为 char * ？如果我在这里有错误的想法或者完全错误，请随时纠正我。

在 C 中，我们可以使用 ## 连接参数化宏的两个参数，如下所示：

arg1##arg2返回arg1arg2

我写了这段代码，希望它能连接并返回一个字符串文字，但我无法让它工作：

#define catstr(x, y) x##y

puts("catting these strings\t" catstr(lmao, elephant));

返回以下错误：

define_directives.c:31:39: error: expected ‘)’ before ‘lmaoelephant’
   31 |         puts("catting these strings\t" catstr(lmao, elephant));
      |                                       ^
      |                                       )

似乎字符串正在连接，但它们需要用引号括起来才能puts打印出来。但是这样做，宏不再起作用。我该如何解决这个问题？

我想做以下事情：

const char errorMsg [64] ( useApple ? "Error Msg Apple\n" : "Error Msg Bee\n" );
MyMethod ( errorMsg );

对于带有签名的方法：

MyMethod(const char* errorMessageInput );

我有一个使用 const char* 的方法，我想在发送它之前创建一个局部变量。我无法分配动态内存，但我可以使用比需要更大的数组（在这种情况下，我将其设为 64）。我将如何编译此代码？

我正在尝试实现我的版本strcat。但是，我收到以下警告，并且我的代码在运行时崩溃。我正在传递&p对main函数p中的变量进行永久更改main。

警告：

note: expected \xe2\x80\x98char **\xe2\x80\x99 but argument is of type \xe2\x80\x98char (*)[10]\xe2\x80\x99\n

代码：

#include <string.h>\n#include <stdio.h>\n\nvoid mystrcat(char **p, char *q)\n{\n    while (**p != '\\0')\n    {\n        *p++;\n    }\n\n    while (*q != '\\0')\n    {\n        **p = *q;\n        (*p)++;\n        q++;\n    }\n    *p = '\\0';\n}\n\nint main()\n{\n    char p[10] = "ravi";\n    char q[12] = "ra";\n\n    mystrcat(&p, q);\n    printf("%s", p);\n}\n

它们与非空终止字符串有何不同？终止字符串的这个 null 是什么？和NULL有什么不同吗？我应该自己以空终止我的字符串，还是编译器会为我做这件事？为什么需要空终止字符串？如何设置代码/数据来处理空终止字符串？

在 c 中 '\0' 空终止符作为文字需要 4 个字节（因为它内部只是零），但为什么在字符数组或字符串中使用时它只需要 1 个字节？这个编译器有魔力吗？

使用动态内存分配来处理空终止符大小时，程序员是否需要特别小心？下面的程序可以吗？

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

int main()
{
   printf("size of null-termination: %lu\n", sizeof('\0')); //outputs 4 bytes
   printf("size of 0: %lu\n", sizeof(0)); // outputs 4 bytes

   char *message = malloc(10);
   message[0] = 'A';
   message[1] = 'B';
   message[2] = 'C';
   message[3] = '\0'; // takes 1-byte in below memory layout(attached image)

   message[4] = 'a';
   message[5] = 'b';
   message[6] = 'c';
   message[7] = '\0'; // takes 1-byte in below memory layout(attached image)

   message[8] = 'X';
   message[9] …