blocks|key|547652|text|您可以按自己喜欢的方式定义数组，但请注意，这种语法是不够的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|547653|const+char+*s+=+{3,+'f',+'o',+'o'};|code-block|syntax|javascript|547654|你需要一个数组而不是一个指针：|547655|const+char+s[]+=+{3,+'f',+'o',+'o'};|547656|请注意，char最多只能存储255个数字(考虑到它没有符号)，这将是您的最大字符串长度。|offset|length|style|CODE|547657|然而，不要期望这会在其他字符串可以工作的地方工作。C字符串不仅被编译器期望以空字符终止，而且在其他方面也是如此。|547658|entityMap^0|0|0|0|0|4|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You can define an array in the way you like, but note that this syntax is not adequate:

<pre><code>const char *s = {3, 'f', 'o', 'o'};
</code></pre>

You need an array instead of a pointer:

<pre><code>const char s[] = {3, 'f', 'o', 'o'};
</code></pre>

Note that a <code>char</code> will only store numbers up to 255 (considering it's not signed) and this will be your maximum string length.

Don't expect this to work where other strings would, however. A C string is expected to terminate with a null character not only by the compiler, but by everything else.

blocks|key|764450|text|您仍然可以使用const+char+*文字和转义序列作为其指示长度的第一个字符：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|764451|const+char+*pascal_string+=+"\x03foo";|code-block|syntax|javascript|764452|它仍然是以null结尾的，但这可能并不重要。|764453|entityMap^0|7|C|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

You can still use a <code>const char *</code> literal and an escape sequence as its first character that indicates the length:

<pre><code>const char *pascal_string = "\x03foo";
</code></pre>

It will still be null-terminated, but that probably doesn't matter.

blocks|key|764587|text|我的方法是创建处理Pascal字符串的函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|764588|void+cstr2pstr(const+char+*cstr,+char+*pstr)+{
++++int+i;
++++for+(i+=+0;+cstr[i];+i%2B%2B)+{
++++++++pstr[i%2B1]+=+cstr[i];
++++}
++++pstr[0]+=+i;
}

void+pstr2cstr(const+char+*pstr,+char+*cstr)+{
++++int+i;
++++for+(i+=+0;+i+<+pstr[0];+i%2B%2B)+{
++++++++cstr[i]+=+pstr[i%2B1];
++++}
++++cstr[i]+=+0;
}|code-block|syntax|javascript|764589|然后我可以这样使用它：|764590|int+main(int+arg,+char+*argv[])+{
++++char+cstr[]+=+"ABCD",+pstr[5],+back[5];
++++cstr2pstr(cstr,+pstr);
++++pstr2cstr(pstr,+back);
++++printf("%25s\n",+back);
++++return+0;
}|764591|这看起来简单，直接，不容易出错，也不是特别尴尬。这可能不是你的问题的解决方案，但我建议你至少考虑使用它。|764592|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

My approach would be to create functions for dealing with Pascal strings:

<pre><code>void cstr2pstr(const char *cstr, char *pstr) {
 int i;
 for (i = 0; cstr[i]; i++) {
 pstr[i+1] = cstr[i];
 }
 pstr[0] = i;
}

void pstr2cstr(const char *pstr, char *cstr) {
 int i;
 for (i = 0; i &lt; pstr[0]; i++) {
 cstr[i] = pstr[i+1];
 }
 cstr[i] = 0;
}
</code></pre>

Then I could use it this way: 

<pre><code>int main(int arg, char *argv[]) {
 char cstr[] = "ABCD", pstr[5], back[5];
 cstr2pstr(cstr, pstr);
 pstr2cstr(pstr, back);
 printf("%s\n", back);
 return 0;
}
</code></pre>

This seems to be simple, straightforward, less error prone and not specially awkward. It may be not the solution to your problem, but I would recommend you to at least think about using it.

blocks|key|547792|text|一种选择可能是滥用预处理器。通过声明一个大小合适的结构并在初始化时填充它，它可以是const。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|547793|#define+DECLARE_PSTR(id,X)+\
++++struct+pstr_##id+{+char+len;+char+data[sizeof(X)];+};+\
++++static+const+struct+pstr_##id+id+=+{sizeof(X)-1,+X};

#define+GET_PSTR(id)+(const+char+*)&(id)

#pragma+pack(push)
#pragma+pack(1)+
DECLARE_PSTR(bob,+"foo");
#pragma+pack(pop)

int+main(int+argc,+char+*argv[])
{
++++const+char+*s+=+GET_PSTR(bob);
++++int+len;

++++len+=+*s%2B%2B;
++++printf("len=%25d\n",+len);
++++while(len--)
++++++++putchar(*s%2B%2B);
++++return+0;
}+|code-block|syntax|javascript|547794|entityMap^0|15|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

One option might be to abuse the preprocessor. By declaring a struct of the right size and populating it on initialization, it can be <code>const</code>.

<pre><code>#define DECLARE_PSTR(id,X) \
 struct pstr_##id { char len; char data[sizeof(X)]; }; \
 static const struct pstr_##id id = {sizeof(X)-1, X};

#define GET_PSTR(id) (const char *)&amp;(id)

#pragma pack(push)
#pragma pack(1) 
DECLARE_PSTR(bob, "foo");
#pragma pack(pop)

int main(int argc, char *argv[])
{
 const char *s = GET_PSTR(bob);
 int len;

 len = *s++;
 printf("len=%d\n", len);
 while(len--)
 putchar(*s++);
 return 0;
} 
</code></pre>

blocks|key|547846|text|您也可以将sizeof应用于字符串文字。这样就不会那么尴尬了|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|547847|const+char+s[]+=+{sizeof+"foo"+-+1u,+'f',+'o',+'o'};|code-block|syntax|javascript|547848|请注意，字符串文字的大小包括终止NUL字符，这就是为什么您必须减去1。但是，它仍然需要大量的输入和混淆:-)|547849|entityMap^0|5|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

You can apply <code>sizeof</code> to string literals as well. This allows a little less awkward

<pre><code>const char s[] = {sizeof "foo" - 1u, 'f', 'o', 'o'};
</code></pre>

Note that the sizeof a string literal includes the terminating NUL character, which is why you have to subtract 1. But still, it's a lot of typing and obfuscated :-)

blocks|key|764765|text|这可能听起来有点极端，但是如果您有许多这类字符串需要频繁更新，您可以考虑编写自己的小工具(也许是perl脚本？)它在主机系统上运行，解析具有自定义格式的输入文件，您可以根据自己的喜好进行设计，并输出.c文件。您可以将其集成到您的makefile或其他文件中，并从此幸福地生活:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|764766|我说的是一个可以转换这个输入的程序(或者你喜欢的另一种语法)：|764767|s+=+"foo";
x+=+"My+string";|code-block|syntax|javascript|764768|此输出是一个.c文件：|764769|const+char+s[]+=+{3,+'f',+'o',+'o'};
const+char+x[]+=+{9,+'M',+'y',+'+',+'s',+'t',+'r',+'i',+'n',+'g'};|764770|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

It may sound a little extreme but if you have many strings of this kind that need frequent updating you may consider writing your own small tool (a perl script maybe?) that runs on the host system, parses an input file with a custom format that you can design to your own taste and outputs a .c file. You can integrate it to your makefile or whatever and live happily ever after :)

I'm talking about a program that will convert this input (or another syntax that you prefer):

<pre><code>s = "foo";
x = "My string";
</code></pre>

To this output, which is a .c file:

<pre><code>const char s[] = {3, 'f', 'o', 'o'};
const char x[] = {9, 'M', 'y', ' ', 's', 't', 'r', 'i', 'n', 'g'};
</code></pre>

blocks|key|764880|text|我认为以下是一个很好的解决方案，但不要忘记启用压缩结构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|764881|#include+<stdio.h>

#define+DEFINE_PSTRING(var,str)+const+struct+{unsigned+char+len;+char+content[sizeof(str)];}+(var)+=+{sizeof(str)-1,+(str)}

DEFINE_PSTRING(x,+"foo");
/*++Expands+to+following:
++++const+struct+{unsigned+char+len;+char+content[sizeof("foo")];}+x+=+{sizeof("foo")-1,+"foo"};
*/

int+main(void)
{
++++printf("%25d+%25s\n",+x.len,+x.content);
++++return+0;
}|code-block|syntax|javascript|764882|一个问题是，它在你的字符串后面添加了一个额外的NUL字节，但这是可取的，因为这样你也可以将它用作普通的c字符串。您还需要将其转换为您的外部库所需的任何类型。|764883|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think the following is a good solution, but don't forget to enable packed structs:

<pre><code>#include &lt;stdio.h&gt;

#define DEFINE_PSTRING(var,str) const struct {unsigned char len; char content[sizeof(str)];} (var) = {sizeof(str)-1, (str)}

DEFINE_PSTRING(x, "foo");
/* Expands to following:
 const struct {unsigned char len; char content[sizeof("foo")];} x = {sizeof("foo")-1, "foo"};
*/

int main(void)
{
 printf("%d %s\n", x.len, x.content);
 return 0;
}
</code></pre>

One catch is, it adds an extra NUL byte after your string, but it can be desirable because then you can use it as a normal c string too. You also need to cast it to whatever type your external library is expecting.

blocks|key|764987|text|这就是为什么在c99中引入了可变长度数组(并避免使用"struct+hack")+IIRC，Pascal字符串被限制为最大长度为255。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|764988|#include+<stdio.h>
#include+<stdlib.h>
#include+<string.h>
#include+<limits.h>+//+For+CHAR_BIT

struct+pstring+{
++++++++unsigned+char+len;
++++++++char+dat[];
++++++++};

struct+pstring+*pstring_new(char+*src,+size_t+len)
{
struct+pstring+*this;
if+(!len)+len+=+strlen(src);

++++/*+if+the+size+does+not+fit+in+the+->len+field:+just+truncate+...+*/
if+(len+>=(1u+<<+(CHAR_BIT+*+sizeof+this->len)))+len+=+(1u+<<+(CHAR_BIT+*+sizeof+this->len))-1;

this+=+malloc(sizeof+*this+%2B+len);
if+(!this)+return+NULL;

this->len+=+len;
memcpy+(this->dat,+src,+len);
return+this;
}

int+main(void)
{
struct+pstring+*pp;

pp+=+pstring_new("Hello,+world!",+0);

printf("%25p:[%25u],+%25*.*s\n",+(void*)+pp
++++++++,+(unsigned+int)+pp->len
++++++++,+(unsigned+int)+pp->len
++++++++,+(unsigned+int)+pp->len
++++++++,+pp->dat
++++++++);
return+0;
}|code-block|syntax|javascript|764989|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is why Variable Length Arrays were introduced in c99 (and to avoid the use of the "struct hack") IIRC, Pascal-strings were limited to a maximal length of 255.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;limits.h&gt; // For CHAR_BIT

struct pstring {
 unsigned char len;
 char dat[];
 };

struct pstring *pstring_new(char *src, size_t len)
{
struct pstring *this;
if (!len) len = strlen(src);

 /* if the size does not fit in the -&gt;len field: just truncate ... */
if (len &gt;=(1u &lt;&lt; (CHAR_BIT * sizeof this-&gt;len))) len = (1u &lt;&lt; (CHAR_BIT * sizeof this-&gt;len))-1;

this = malloc(sizeof *this + len);
if (!this) return NULL;

this-&gt;len = len;
memcpy (this-&gt;dat, src, len);
return this;
}

int main(void)
{
struct pstring *pp;

pp = pstring_new("Hello, world!", 0);

printf("%p:[%u], %*.*s\n", (void*) pp
 , (unsigned int) pp-&gt;len
 , (unsigned int) pp-&gt;len
 , (unsigned int) pp-&gt;len
 , pp-&gt;dat
 );
return 0;
}
</code></pre>

blocks|key|548213|text|GCC和clang+(可能还有其他人)接受-fpascal-strings选项，该选项允许您通过将字符串中出现的第一个内容作为\p来声明pascal样式的字符串文字，例如"\pfoo"。不完全是可移植的，但肯定比时髦的宏或它们的运行时构造更好。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|548214|有关详细信息，请参阅here。|548215|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20151222160405/http://fizz.phys.dal.ca/%257Ejordan/gcc-4.0.1/gcc/Pascal-Strings.html^0|L|G|1R|2|2D|7|0|A|4|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

GCC and clang (and possibly others) accept the <code>-fpascal-strings</code> option which allows you to declare pascal-style string literals by having the first thing that appears in the string be a <code>\p</code>, e.g. <code>&quot;\pfoo&quot;</code>. Not exactly portable, but certainly nicer than funky macros or the runtime construction of them.
See <a href="http://web.archive.org/web/20151222160405/http://fizz.phys.dal.ca/%7Ejordan/gcc-4.0.1/gcc/Pascal-Strings.html" rel="nofollow noreferrer">here</a> for more info.

blocks|key|548247|text|以下是我的答案，其中包含一个append操作，该操作使用alloca()进行自动存储。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|548248|#include+<stdio.h>
#include+<string.h>
#include+<alloca.h>

struct+pstr+{
++unsigned+length;
++char+*cstr;
};

#define+PSTR(x)+((struct+pstr){sizeof+x+-+1,+x})

struct+pstr+pstr_append+(struct+pstr+out,
+++++++++++++const+struct+pstr+a,
+++++++++++++const+struct+pstr+b)
{
++memcpy(out.cstr,+a.cstr,+a.length);+
++memcpy(out.cstr+%2B+a.length,+b.cstr,+b.length+%2B+1);+
++out.length+=+a.length+%2B+b.length;
++return+out;
}

#define+PSTR_APPEND(a,b)+\
++pstr_append((struct+pstr){0,+alloca(a.length+%2B+b.length+%2B+1)},+a,+b)

int+main()
{
++struct+pstr+a+=+PSTR("Hello,+Pascal!");
++struct+pstr+b+=+PSTR("I+didn't+C+you+there.");

++struct+pstr+result+=+PSTR_APPEND(PSTR_APPEND(a,+PSTR("+")),+b);

++printf("\"%25s\"+is+%25d+chars+long.\n",+result.cstr,+result.length);
++return+0;
}+|code-block|syntax|javascript|548249|您可以使用c字符串和strlen来完成相同的任务。因为alloca和strlen都更喜欢短字符串，所以我认为这会更有意义。|548250|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's my answer, complete with an append operation that uses alloca() for automatic storage.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;alloca.h&gt;

struct pstr {
 unsigned length;
 char *cstr;
};

#define PSTR(x) ((struct pstr){sizeof x - 1, x})

struct pstr pstr_append (struct pstr out,
 const struct pstr a,
 const struct pstr b)
{
 memcpy(out.cstr, a.cstr, a.length); 
 memcpy(out.cstr + a.length, b.cstr, b.length + 1); 
 out.length = a.length + b.length;
 return out;
}

#define PSTR_APPEND(a,b) \
 pstr_append((struct pstr){0, alloca(a.length + b.length + 1)}, a, b)

int main()
{
 struct pstr a = PSTR("Hello, Pascal!");
 struct pstr b = PSTR("I didn't C you there.");

 struct pstr result = PSTR_APPEND(PSTR_APPEND(a, PSTR(" ")), b);

 printf("\"%s\" is %d chars long.\n", result.cstr, result.length);
 return 0;
} 
</code></pre>

You could accomplish the same thing using c strings and strlen. Because both alloca and strlen prefer short strings I think that would make more sense.

In C, is there a good way to define length first, Pascal-style strings as constants, so they can be placed in ROM? (I'm working with a small embedded system with a non-GCC ANSI C compiler).

A C-string is <code>0</code> terminated, eg. {<code>'f'</code>,<code>'o'</code>,<code>'o'</code>,<code>0</code>}.

A Pascal-string has the length in the first byte, eg. {<code>3</code>,<code>'f'</code>,<code>'o'</code>,<code>'o'</code>}.

I can declare a C-string to be placed in ROM with:

<pre><code>const char *s = "foo";
</code></pre>

For a Pascal-string, I could manually specify the length:

<pre><code>const char s[] = {3, 'f', 'o', 'o'};
</code></pre>

But, this is awkward. Is there a better way? Perhaps in the preprocessor?

Declaring Pascal-style strings in C

嵌入式系统

编译器

在C语言中，有没有一种好的方法将长度优先的Pascal风格的字符串定义为常量，这样它们就可以放在ROM中？(我使用的是一个小型嵌入式系统，使用的是非GCC ANSI C编译器)。C字符串以0结尾，例如。{'f'，'o'，'o'，0}。Pascal字符串的长度为第一个字节，例如。{3，'f'，'o'，'o'}。我可以使用...

问在C++中声明Pascal风格的字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中声明Pascal风格的字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中声明Pascal风格的字符串
EN