blocks|key|5191241|text|一旦你将一个char指针传递给你正在编写的函数，你将不知道有多少内存被分配给s。你需要将这个大小作为参数传递给函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5191242|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Once you pass a char pointer to the function you are writing, you will loose knowledge for how much memory is allocated to s. You will need to pass this size as argument to the function.

blocks|key|443110|text|您可以在编译时使用sizeof进行检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|443111|char+s[80]+=+"";
int+i+=+sizeof+s+;+//+should+return+80|code-block|syntax|javascript|443112|请注意，如果s是指针，则此操作将失败：|443113|char+*s+=+"";
int+j+=+sizeof+s;++/*+probably+4+or+8.+*/|443114|数组不是指针。为了跟踪分配给指针的大小，程序只需跟踪它。此外，您不能将数组传递给函数。当您使用数组作为函数的参数时，编译器会将其转换为指向第一个元素的指针，因此，如果您希望该大小可用于被调用的函数，则必须将其作为参数传递。例如：|443115|char+s[+SIZ+]+=+"";
foo(+s,+sizeof+s+);|443116|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can use sizeof to check at compile time:

<pre><code>char s[80] = "";
int i = sizeof s ; // should return 80
</code></pre>

Note that this fails if s is a pointer:

<pre><code>char *s = "";
int j = sizeof s; /* probably 4 or 8. */
</code></pre>

Arrays are not pointers. To keep track of the size allocated for a pointer, the program simply must keep track of it. Also, you cannot pass an array to a function. When you use an array as an argument to a function, the compiler converts that to a pointer to the first element, so if you want the size to be avaliable to the called function, it must be passed as a parameter. For example:

<pre><code>char s[ SIZ ] = "";
foo( s, sizeof s );
</code></pre>

blocks|key|1358614|text|char+s[80]+=+"";
int+i+=+someFunction(s);+//+should+return+80|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1358615|在表达式中，s是指向数组s的第一个元素的指针。不能仅使用指向数组对象第一个元素的指针的值信息来推断数组对象的大小。您唯一能做的就是在声明数组(这里是sizeof+s)之后存储数组大小的信息，然后将此信息传递给需要它的函数。|unstyled|offset|length|style|CODE|1358616|entityMap^0|0|6|1|C|1|22|8|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]|$G|S|H|T|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|U|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>char s[80] = "";
int i = someFunction(s); // should return 80
</code></pre>

In an expression <code>s</code> is a pointer to the first element of the array <code>s</code>. You cannot deduce the size of an array object with the only information of the value of a pointer to its first element. The only thing you can do is to store the information of the size of the array after you declare the array (here <code>sizeof s</code>) and then pass this information to the functions that need it.

blocks|key|1358655|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1358656|所以这一切都归结为以下问题:如何找到编译器为我的目的地“字符串”保留了多少内存？|blockquote|1358657|1358658|1358659|没有可移植的方法来找出分配了多少内存。你必须自己跟踪它。|1358660|实现必须跟踪有多少内存被malloc到一个指针，它可能会让你找到一些可用的东西。例如，glibc的malloc.h公开了|offset|length|style|CODE|1358661|size_t+malloc_usable_size+(void+*__ptr)|code-block|syntax|javascript|1358662|这使您可以访问大致的信息，但是，它不会告诉您请求了多少，而是告诉您有多少是可用的。当然，这只适用于你从malloc+(和朋友)那里获得的指针。对于数组，只能在数组本身在作用域中的情况下使用sizeof。|1358663|entityMap^0|0|0|0|0|0|C|6|1D|8|0|0|1F|6|2M|6|0^^$0|@$1|2|3|-4|4|5|6|W|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|X|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|Y|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|10|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|11|7|@$J|12|K|13|L|M]|$J|14|K|15|L|M]]|8|@]|9|$]]|$1|N|3|O|4|P|6|16|7|@]|8|@]|9|$Q|R]]|$1|S|3|T|4|5|6|17|7|@$J|18|K|19|L|M]|$J|1A|K|1B|L|M]]|8|@]|9|$]]|$1|U|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]]|V|$]]

<blockquote>
 So this all sums up to the following question: How to find our how much memory the compiler reserved for my destination "string"???
</blockquote>

There is no portable way to find out how much memory is allocated. You have to keep track of it yourself.

The implementation must keep track of how much memory was <code>malloc</code>ed to a pointer, and it may make something available for you to find out. For example, glibc's <code>malloc.h</code> exposes

<pre><code>size_t malloc_usable_size (void *__ptr)
</code></pre>

that gives you access to roughly that information, however, it doesn't tell you how much you requested, but how much is usable. Of course, that only works with pointers you obtained from <code>malloc</code> (and friends). For an array, you can only use <code>sizeof</code> where the array itself is in scope.

blocks|key|4708850|text|没有可移植的方法可以做到这一点。但是，实现肯定需要在内部了解此信息。基于Unix的OSes，如Linux和OS，提供了执行此任务的函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4708851|//+OS+X
#include+<malloc/malloc.h>

size_t+allocated+=+malloc_size(somePtr);

//+Linux
#include+<malloc.h>

size_t+allocated+=+malloc_usable_size(somePtr);


//+Maybe+Windows...

size_t+allocated+=+_msize(somePtr);|code-block|syntax|javascript|4708852|entityMap^0|2|4|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|$]]

There's no portable way to do it. However, the implementation certainly needs to know this information internally. Unix-based OSes, like Linux and OS X, provide functions for this task:

<pre><code>// OS X
#include &lt;malloc/malloc.h&gt;

size_t allocated = malloc_size(somePtr);

// Linux
#include &lt;malloc.h&gt;

size_t allocated = malloc_usable_size(somePtr);


// Maybe Windows...

size_t allocated = _msize(somePtr);
</code></pre>

blocks|key|4708885|text|标记由malloc返回的成员的一种方法是始终malloc一个额外的大小(Size_t)字节。将其与malloc返回的地址相加，您就有了一个存储空间来存储实际长度。把错位的size+--+sizeof+(size_t)存储在那里，你就有了新函数集的基础。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4708886|当你把两个这样的指针传递给你的新的特殊的strcpy时，你可以从指针中减去sizeof(size_t)，然后直接获取它们的大小。这让您可以决定是否可以安全地复制内存。|4708887|如果您正在执行strcat，那么两个大小以及计算strlen意味着您可以执行相同类型的检查，以查看strcat的结果是否会溢出内存。|4708888|这是可行的。这可能是更多的麻烦比它的价值。|4708889|想一想，如果你传入一个没有错位的字符指针，会发生什么。假设大小在指针之前。这种假设是错误的。在这种情况下，尝试访问大小是未定义的行为。如果你幸运的话，你可能会得到一个信号。|4708890|这种实现的另一个含义是，当您要释放内存时，您必须准确地传递malloc返回的指针。如果你做得不对，堆损坏是可能的。|4708891|长话短说。不要那样做。|4708892|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

A way to tag the member returned by malloc is to always malloc an extra sizeof(size_t) bytes. Add that to the address malloc returns, and you have a storage space for storing the actual length. Store the malloced size - the sizeof (size_t) there, and you have the basis for your new set of functions.

When you pass two of these sorts of pointers into your new-special strcpy, you can subtract sizeof(size_t) off the pointers, and access the sizes directly. That lets you decide if the memory can be copied safely.

If you are doing strcat, then the two sizes, along with calculating the strlens means you can do the same sort of check to see if the results of the strcat will overflow the memory.

It's doable.
It's probably more trouble than it's worth.

Consider what happens if you pass in a character pointer that was not mallocated.
The assumption is that the size is before the pointer. That assumption is false.
Attempting to access the size in that case is undefined behavior. If you are lucky, you may get a signal.

One other implication of that sort of implementation is that when you go to free the memory, you have to pass in exactly-the-pointer-that-malloc-returned. If you don't get that right, heap corruption is possible.

Long story short...
Don't do it that way.

blocks|key|5191457|text|对于在你的程序中使用字符缓冲区的情况，你可以做一些烟雾和镜子来获得你想要的效果。就像这样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5191458|char+input[]+=+"test";
char+output[3];

if+(sizeof(output)+<+sizeof(input))
{
++++memcpy(output,input,sizeof(input)+%2B+1);
}
else
{
++++printf("Overflow+detected+value+<%25s>\n",input);
}|code-block|syntax|javascript|5191459|可以通过将代码包装在宏中来改进错误消息。|5191460|#define+STRCPYX(output,input)++++++++++++++++++++++++++++++++++++++++\
if+(sizeof(output)+<+sizeof(input))++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++memcpy(output,input,sizeof(input)+%2B+1);++++++++++++++++++++++++++\
}++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
else+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++printf("STRCPYX+would+overflow+%25s+with+value+<%25s>+from+%25s\n",++++\
+++++++++++++++++++++++++++++++++++#output,+++++++input,+++#input);++\
}++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\

char+input[]+=+"test";
char+output[3];
STRCPYX(output,input);|5191461|虽然这确实给了你想要的东西，但同样的风险也存在。|5191462|char+*input+=+"testing+123+testing";
char+output[9];
STRCPYX(output,input);|5191463|输入的大小是8，输出的大小是9，输出的值以“测试”结束。|5191464|C语言的设计初衷并不是为了防止程序员做错误的事情。这有点像你试图往上游划水:)这是一个很好的练习。|5191465|entityMap^0|0|0|0|0|0|0|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|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|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|$]]

For situations where you are using character buffers in your program, you can do some smoke and mirrors to get the effect that you want. Something like this.

<pre><code>char input[] = "test";
char output[3];

if (sizeof(output) &lt; sizeof(input))
{
 memcpy(output,input,sizeof(input) + 1);
}
else
{
 printf("Overflow detected value &lt;%s&gt;\n",input);
}
</code></pre>

One can improve the error message by wraping the code in a macro.

<pre><code>#define STRCPYX(output,input) \
if (sizeof(output) &lt; sizeof(input)) \
{ \
 memcpy(output,input,sizeof(input) + 1); \
} \
else \
{ \
 printf("STRCPYX would overflow %s with value &lt;%s&gt; from %s\n", \
 #output, input, #input); \
} \

char input[] = "test";
char output[3];
STRCPYX(output,input);
</code></pre>

While this does give you what you want, the same sort of risks apply.

<pre><code>char *input = "testing 123 testing";
char output[9];
STRCPYX(output,input);
</code></pre>

the size of input is 8, and output is 9, the value of output ends up as "Testing "

C was not designed to protect the programmer from doing things incorrectly.
It is kind of like you are attempting to paddle upriver :)
It is a good exercise to think about.

blocks|key|4708989|text|尽管数组和指针看起来可以互换，但它们在一个重要方面有所不同:数组有大小。但是，由于数组在传递给函数时会“降级”为指针，因此会丢失大小信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4708990|问题是，在某些情况下，您知道对象的大小-因为您将其分配或声明为特定的大小。C语言使您有责任在必要时保留和传播这些信息。因此，在您的示例之后：|4708991|char+s[80]+=+"";++//+sizeof(s)+here+is+80,+because+an+array+has+size
int+i+=+someFunction(s,+sizeof(s))+;+//+You+have+to+tell+the+function+how+big+the+array+is.|code-block|syntax|javascript|4708992|在someFunction()中没有确定数组大小的“神奇”方法，因为该信息被丢弃(出于性能和效率的原因-C在这方面相对较低，并且不添加不显式的代码或数据)；如果需要该信息，则必须显式传递该信息。|offset|length|style|CODE|4708993|传递字符串并保留大小信息，甚至通过复制而不是引用传递字符串的一种方法是将字符串包装在结构中，如下所示：|4708994|typedef+struct
{
++++char+s[80]+;

}+charArray_t+;|4708995|然后|4708996|charArray_t+s+;
int+i+=+someFunction(+&s+)+;|4708997|对someFunction()的定义如下：|4708998|int+someFunction(+charArray_t*+s+)+
{
++++return+sizeof(+s->s+)+;+
}|4708999|但是，这样做并不能真正获得太多好处--只要避免额外的参数即可；实际上，您失去了一些灵活性，因为someFunction()现在只接受由charrArray_t定义的固定数组长度，而不是任何数组。有时这样的限制是有用的。这种方法的一个特点是你可以pass+by+copy这个：|4709000|int+i+=+someFunction(+s+)+;|4709001|4709002|int+someFunction(+charArray_t+s+)+
{
++++return+sizeof(+s.s+)+;+
}|4709003|因为与数组不同的结构可以通过这种方式传递。您也可以同样地通过复制返回。然而，它的效率可能有点低。然而，有时方便和安全超过了低效。|4709004|entityMap^0|0|0|0|1|E|0|0|0|0|0|1|E|0|0|1B|E|1V|C|3E|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1E|8|@$K|1F|L|1G|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1P|8|@$K|1Q|L|1R|M|N]|$K|1S|L|1T|M|N]|$K|1U|L|1V|M|N]]|9|@]|A|$]]|$1|12|3|13|5|F|7|1W|8|@]|9|@]|A|$G|H]]|$1|14|3|T|5|6|7|1X|8|@]|9|@]|A|$]]|$1|15|3|16|5|F|7|1Y|8|@]|9|@]|A|$G|H]]|$1|17|3|18|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|1A|$]]

Although arrays and pointers can appear to be interchangeable, they differ in one important aspect; an array has size. However because an array when passed to a function "degrades" to a pointer, the size information is lost.

The point is that at some point you know the size of the object - because you allocated it or declared it to be a certain size. The C language makes it your responsibility to retain and disseminate that information as necessary. So after your example:

<pre><code>char s[80] = ""; // sizeof(s) here is 80, because an array has size
int i = someFunction(s, sizeof(s)) ; // You have to tell the function how big the array is.
</code></pre>

There is no "magic" method of determining the size of the array within <code>someFunction()</code>, because that information is discarded (for reasons of performance and efficiency - C is relatively low level in this respect, and does not add code or data that is not explicit); if the information is needed, you must explicitly pass it.

One way in which you can pass a string and retain size information, and even pass the string by copy rather than by reference is to wrap the string in a struct thus:

<pre><code>typedef struct
{
 char s[80] ;

} charArray_t ;
</code></pre>

then

<pre><code>charArray_t s ;
int i = someFunction( &amp;s ) ;
</code></pre>

with a definition of <code>someFunction()</code> like: 

<pre><code>int someFunction( charArray_t* s ) 
{
 return sizeof( s-&gt;s ) ; 
}
</code></pre>

You don't really gain much by doing that however - just avoid the additional parameter; in fact you loose some flexibility because <code>someFunction()</code> now only takes a fixed array length defined by <code>charrArray_t</code>, rather than any array. Sometimes such restrictions are useful. On feature of this approach is that you can <code>pass by copy</code> this:

<pre><code>int i = someFunction( s ) ;
</code></pre>

then 

<pre><code>int someFunction( charArray_t s ) 
{
 return sizeof( s.s ) ; 
}
</code></pre>

since structures unlike arrays can be passed this way. You can equally return by copy as well. It can be somewhat inefficient however. Sometimes the convenience and safety outweigh the inefficiency however.

I'm trying to learn C and as a start, i set off writing a strcpy for my own practice. As we know, the original strcpy easily allows for security problems so I gave myself the task to write a "safe" strcpy.

The path I've chosen is to check wether the source string (character array) actually fits in the destination memory. As I've understood it, a string in C is nothing more than a pointer to a character array, 0x00 terminated.

So my challenge is how to find how much memory the compiler actually reserved for the destination string?

I tried:

<pre><code>sizeof(dest)
</code></pre>

but that doesn't work, since it will return (as I later found out) the size of dest which is actually a pointer and on my 64 bit machine, will always return 8.

I also tried:

<pre><code>strlen(dest)
</code></pre>

but that doesn't work either because it will just return the length until the first 0x0 is encountered, which doesn't necessarily reflect the actual memory reserved.

So this all sums up to the following question: How to find our how much memory the compiler reserved for my destination "string"???

Example:

<pre><code>char s[80] = "";
int i = someFunction(s); // should return 80
</code></pre>

What is "someFunction"? 

Thanks in advance!

Find the size of reserved memory for a character array in C

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试学习C语言，作为一个开始，我开始为自己的实践编写一个strcpy。正如我们所知，最初的strcpy很容易出现安全问题，所以我给自己的任务是编写一个“安全的”strcpy。我选择的路径是检查源字符串(字符数组)是否实际适合目标内存。据我所知，C中的字符串只不过是指向字符数组的指针，以0x00结尾。所以我的挑战是...

问在C中查找字符数组的保留内存大小
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C中查找字符数组的保留内存大小EN