blocks|key|533702|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|533703|我不知道如何确定任意"r1“的”大小“。|blockquote|533704|533705|533706|您不能这样做:在调用之后，您传递给malloc的有关大小的信息将不可逆转地丢失。在这一点上，您所拥有的只是指向至少24字节的内存块的指针。如果您需要大小，您需要将其存储在其他地方-例如，在您随身携带的单独变量中。|offset|length|style|CODE|533707|此问题的两个典型解决方法包括(1)在分配的空间中存储以零终止的字符串，并使用该字符串的长度作为已分配区块大小的代理，以及(2)定义包含大小和已分配指针的自己的结构。这两种解决方案都不是理想的，但至少你有选择。|533708|entityMap^0|0|0|0|0|H|6|0|0^^$0|@$1|2|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Q|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|R|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|T|7|@$H|U|I|V|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|W|7|@]|8|@]|9|$]]|$1|N|3|-4|4|5|6|X|7|@]|8|@]|9|$]]]|O|$]]

<blockquote>
 I can't figure out how to determine the "size" of an arbitrary "r1".
</blockquote>

You cannot do that: the information about the size that you passed to <code>malloc</code> is irreversibly lost after the call. All you have at that point is a pointer to the chunk of at least 24 bytes of memory. If you need the size, you need to store it somewhere else - for example, in a separate variable that you carry around.

Two typical work-arounds to this issue include (1) storing a zero-terminated string in the allocated space, and using the length of that string as the proxy to the size of the allocated chunk, and (2) defining your own structure that contains both the size and the allocated pointer. Neither solution is ideal, but at least the choice is with you.

blocks|key|602890|text|r1的类型是char*+(字符指针)，所以像所有指针一样，它的大小是4(或8，取决于您的情况)。不管你分配给它的内存块有多大。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|602891|你不能从指针中检索分配的块的大小，所以如果你以后需要这个大小，你必须自己记住这个大小(例如，通过将它存储在一个不同的变量中)。|602892|entityMap^0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

The type of <code>r1</code> is a char* (char pointer), so, like all pointers, its size is 4 (or 8, depending on your situation). No matter the size of the memory block you're allocating to it.

You can't retrieve the size of the allocated block from a pointer, so if you need the size later, you will have to remember the size yoursef (e.g. by storing it in a different variable).

blocks|key|602917|text|r1是一个指针类型的变量，它的大小是固定的，并且总是相同的(就像任何给定类型的变量的大小一样)，它不会大于(并且通常等于)+sizeof(void+*)。你真正想知道的是位于*r1的数组的大小(注意星号)，而这是你不知道的。您必须自己跟踪它，通常如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|602918|size_t+const+n+=+get_some_number();
foo+*+p+=+calloc(n,+sizeof(foo));|code-block|syntax|javascript|602919|现在使用pair+(p，n)来描述动态数组。|BOLD|602920|(请注意，C99和C11有可变长度数组的概念，在其上下文中，sizeof实际上(有时)给出了实际的数组大小，但这有点模糊，而且在任何情况下它都不是您所要求的。)|602921|entityMap^0|0|2|1Q|E|2F|3|0|0|4|4|A|1|C|1|0|U|6|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Z|8|@$9|10|A|11|B|M]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|Q|$]]

<code>r1</code> is a variable of pointer type, and its size is fixed and always the same (just like the size of any variable of a given type), which is no larger than (and usually equal to) <code>sizeof(void *)</code>. What you really want to know is the size of the array that's sitting at <code>*r1</code> (note the asterisk), and that is something you cannot know. You have to keep track of it yourself, typically like this:

<pre><code>size_t const n = get_some_number();
foo * p = calloc(n, sizeof(foo));
</code></pre>

Now you use the pair (<code>p</code>, <code>n</code>) to describe your dynamic array.

(Note that C99 and C11 have the notion of a variable-length array, in whose context <code>sizeof</code> does actually (sometimes) give you the actual array size, but that's a somewhat murky affair, and in any case it isn't what you asked for.)

blocks|key|4639955|text|当你分配内存时，你会得到一个指针，它有一个固定的大小，所以没有办法用sizeof得到分配的内存的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4639956|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|$]]

When you allocate memory, you get back a pointer, which has a fixed size, so there's no way to get the size of the allocated memory with sizeof.

blocks|key|532984|text|您可以将大小作为另一个参数进行传递：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|532985|void+dec2bin(int+dec,+char+*+bin,+size_t+max_chars);|code-block|syntax|javascript|532986|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|$]]

You may just pass the size as another parameter:

<pre><code>void dec2bin(int dec, char * bin, size_t max_chars);
</code></pre>

blocks|key|602988|text|正如其他人所说，如果它只是一个指针，你将不能告诉任何事情(除非它是以零结束的，在这种情况下，你可以迭代，直到你遇到一个等于零的元素(不是字符'0'))。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|602989|但是，如果您按如下方式进行设置，则可以在调用sizeof()...之后实际看到缓冲区大小。至少在您将其发送到函数之前，数组会衰减为一个普通的char*指针。|offset|length|style|CODE|602990|void+test(+char*+s+)
{
+++int+i2+=+sizeof(+s+)+/+sizeof(+char+);
}

char+c1[]+=+"Testing!";
int+i1+=+sizeof(+c1+)+/+sizeof(+char+);+//+i1+is+9+(size+of+buffer)
test(+c1+);+++++++++++++++++++++++++++++//+i2+is+4+(size+of+pointer)|code-block|syntax|javascript|602991|entityMap^0|0|M|8|1Y|5|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

As others have said, if it's just a pointer, you won't be able to tell anything (unless it's zero-terminated, in which case you can just iterate until you hit an element equal to zero (not the character '0')).

However, if you set it up as follows, you can actually see the buffer size after calling <code>sizeof()</code>... at least until you send it to a function, where the array decays to a plain <code>char*</code> pointer.

<pre><code>void test( char* s )
{
 int i2 = sizeof( s ) / sizeof( char );
}

char c1[] = "Testing!";
int i1 = sizeof( c1 ) / sizeof( char ); // i1 is 9 (size of buffer)
test( c1 ); // i2 is 4 (size of pointer)
</code></pre>

I'm trying to write a function that converts a base 10 integer to a binary number.

I am constructing the function like this:

<pre><code>void dec2bin(int dec, char * bin);
</code></pre>

The function will store the binary result by means of the pointer in the argument. It is passed a variable declared elsewhere as follows:

<pre><code>char *r1 = (char *)malloc(24);
</code></pre>

The first thing the function has to do is fill the "24 bit result" with all zeros. It works great now since I've coded it based on me knowing the "size," but I can't figure out how to determine the "size" of an arbitrary "r1". Every way I can think to use the sizeof function does not give me 24.

I am confused at this point, and not connecting the relationship between the respective sizes of a char, char*, etc and how I can use those sizes to get what I'm looking for with respect to "r1".

Would someone mind giving me a pointer? Pun intended.

Thanks!

Confused with results of sizeof() function

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在尝试编写一个将基数为10的整数转换为二进制数的函数。我像这样构造函数：void dec2bin(int dec, char * bin);该函数将通过参数中的指针存储二进制结果。它被传递给一个在别处声明的变量，如下所示：char *r1 = (char *)malloc(24);该函数必须做的第一件事是用全零填充...

问与sizeof()函数的结果混淆
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问与sizeof()函数的结果混淆EN