blocks|key|1670335|text|memset对字节进行操作，而不是浮动，所有字节设置为-1的double不等于-1。我想你是在找std::fill|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1670336|#include+<algorithm>

std::fill(dp,+dp+%2B+505,+-1.0);|code-block|syntax|javascript|1670337|或者，在C%2B%2B11中：|1670338|#include+<algorithm>
#include+<iterator>

std::fill(std::begin(dp),+std::end(dp),+-1.0);|1670339|entityMap^0|0|6|U|6|1C|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

<code>memset</code> operates on bytes, not floats, and a <code>double</code> with all bytes set to -1 does not equal -1. I think you're looking for <code>std::fill</code>:

<pre><code>#include &lt;algorithm&gt;

std::fill(dp, dp + 505, -1.0);
</code></pre>

Or, in C++11:

<pre><code>#include &lt;algorithm&gt;
#include &lt;iterator&gt;

std::fill(std::begin(dp), std::end(dp), -1.0);
</code></pre>

blocks|key|2909182|text|您已经将数组的每个元素设置为用字节0xFF填充(即-1的char表示)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2909183|没有浮点数是由一系列0xFF字节表示的，因此在打印double时，您可以看到NaN+(即“不是一个数字”)。这与memset‘将字节变为零形成了明显的对比，这是合法的，因为0字节的字符串是值为零的double。参见在双重数组上使用memset(,0，)合法吗？。|2909184|如果您打算将每个条目设置为-1.0+(即双)，那么在C%2B%2B中使用std::fill或std::fill_n，在C中使用循环。|2909185|int+n;
for+(n+=+0+;+n+<+505+;+n%2B%2B)
++++dp[n]+=+-1.0;|code-block|syntax|javascript|2909186|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4629853/is-it-legal-to-use-memset-0-on-array-of-doubles^0|H|4|P|2|S|4|0|A|4|P|6|12|3|1K|6|2Q|6|2Z|N|0|0|D|4|W|9|16|B|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|H|3|I|5|6|7|1H|8|@$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1O|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

You have set each element of the array to be filled with the byte <code>0xFF</code> (i.e. the <code>char</code> representation of <code>-1</code>).

No floating point number is represented by a series of <code>0xFF</code> bytes, so on printing the <code>double</code>, you see <code>NaN</code> (i.e. 'not a number'). This is in apparent contrast to <code>memset</code>'ting the bytes to zero, which is legal as a string of 0 bytes is a <code>double</code> with value zero. See <a href="https://stackoverflow.com/questions/4629853/is-it-legal-to-use-memset-0-on-array-of-doubles">Is it legal to use memset(,0,) on array of doubles?</a>.

If you meant to set every entry to <code>-1.0</code> (i.e. a double), then use <code>std::fill</code> or <code>std::fill_n</code> in C++ or a loop in C, e.g.

<pre><code>int n;
for (n = 0 ; n &lt; 505 ; n++)
 dp[n] = -1.0;
</code></pre>

blocks|key|2909196|text|在C%2B%2B中，您可以编写：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2909197|double+initValue+=+-1;
std::fill_n(dp,+505,+initValue);|code-block|syntax|javascript|2909198|如果使用非双值设置双数组，则无法工作。|2909199|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|$]]

In C++, you can write:

<pre><code>double initValue = -1;
std::fill_n(dp, 505, initValue);
</code></pre>

memsetting a double array with a non-double value won't work.

blocks|key|1670467|text|来自memset的手册页|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1670468|memset()函数用常量字节c填充由s指向的内存区域的前n个字节。|blockquote|1670469|问题是，您希望用常量double填充一个数组，但是sizeof(double)+>+1，因此memset实际上填充了垃圾，而垃圾恰好以非数的形式结束。|1670470|如果您正在使用C%2B%2B，则std::fill函数是您的朋友。实际上，由于您是第一次写入数组，所以std::uninitialized_fill是正确的。虽然对于内置的double类型，应该没有区别，但始终是好的，准确。|1670471|constexpr+std::size_t+length+=+505;
double+values[length];
std::uninitialized_fill(values,+values+%2B+length,+-1.0);|code-block|syntax|javascript|1670472|entityMap|0|LINK|mutability|MUTABLE|url|http://linux.die.net/man/3/memset|1|https://en.wikipedia.org/wiki/NaN|2|http://en.cppreference.com/w/cpp/algorithm/fill|3|http://en.cppreference.com/w/cpp/memory/uninitialized_fill^0|2|6|2|6|0|0|0|8|0|A|6|P|I|1A|6|1V|2|1|0|C|9|1B|N|2A|6|C|9|2|1B|N|3|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|F|3|G|5|H|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|K|3|L|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@$9|1V|A|1W|1|1X]|$9|1Y|A|1Z|1|20]]|E|$]]|$1|M|3|N|5|O|7|21|8|@]|D|@]|E|$P|Q]]|$1|R|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]|Z|$5|U|V|W|E|$X|10]]|11|$5|U|V|W|E|$X|12]]|13|$5|U|V|W|E|$X|14]]]]

From the man page of <a href="http://linux.die.net/man/3/memset" rel="nofollow"><code>memset</code></a>:

<blockquote>
 The <code>memset()</code> function fills the first n bytes of the memory area pointed to by s with the constant byte c.
</blockquote>

The problem is that you want to fill an array of <code>double</code>s with the constant <code>-1.0</code> but <code>sizeof(double) &gt; 1</code> so <code>memset</code> actually fills in garbage which happens to end up as a <a href="https://en.wikipedia.org/wiki/NaN" rel="nofollow">NaN</a>.

If you are using C++, the <a href="http://en.cppreference.com/w/cpp/algorithm/fill" rel="nofollow"><code>std::fill</code></a> function is your friend. Actually, since you are writing to your array for the first time, <a href="http://en.cppreference.com/w/cpp/memory/uninitialized_fill" rel="nofollow"><code>std::uninitialized_fill</code></a> would be correct. Although for the builtin <code>double</code> type there should be no difference but it is always good to be precise.

<pre><code>constexpr std::size_t length = 505;
double values[length];
std::uninitialized_fill(values, values + length, -1.0);
</code></pre>

blocks|key|1670508|text|南的意思不是数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1670509|不明白为什么它不起作用。可能是因为没有设置精度：(cout.precision(15);)|1670510|检查这个：如何使用cout打印完全精确的双值？|offset|length|1670511|但是我一点也不确定它是否会起作用:o我检查了memset源代码，负:D没有问题。|1670512|但这可能是双打的问题：|1670513|memset(dst0,+c0,+length)+void+*dst0;
register+int+c0;
register+size_t+length;|code-block|syntax|javascript|1670514|您是否尝试过使用Werror标志进行编译？|1670515|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/554063/how-do-i-print-a-double-value-with-full-precision-using-cout^0|0|0|5|I|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$F|13|G|14|1|15]]|A|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|18|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

nan means not a number.

cant see why its not working.
maybe because precision is not set : (cout.precision(15);)

check this:
<a href="https://stackoverflow.com/questions/554063/how-do-i-print-a-double-value-with-full-precision-using-cout">How do I print a double value with full precision using cout?</a>

But im not sure at all it will works :o
i checked memset source code and there's no problem with negative :D

But it can be a problem with doubles :

<pre><code>memset(dst0, c0, length) void *dst0;
register int c0;
register size_t length;
</code></pre>

Have you tried to compile with Werror flag ?

blocks|key|1670551|text|memset设置字节，因此可以得到double-values，其中每个字节都是-1。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1670552|相反，在C%2B%2B中使用std::vector，然后编写|1670553|vector<double>+dp(+505,+-1.0+);|code-block|syntax|javascript|1670554|就这么简单。|1670555|如果dp是一个全局向量，并且需要多次将其设置为-1，那么您可以这样做：|1670556|dp+=+vector<double>(+dp.size(),+-1.0+);|1670557|然而，它是全局变量。|1670558|或者，您可以使用std::fill，或者仅仅使用一个循环，或者使用任何仍然将double值作为double值处理的技术。但是，由于许多其他原因，std::vector比大大简化填充任务更可取。特别是，可以调整std::vector的大小，它负责复制，并自动化内存管理，对您正确和透明地执行该部分操作。|1670559|entityMap|0|LINK|mutability|MUTABLE|url|https://softwareengineering.stackexchange.com/questions/148108/why-is-global-state-so-evil^0|0|6|H|6|13|2|0|A|B|0|0|0|2|2|N|2|0|0|5|4|0|0|8|9|12|6|1B|6|20|B|2W|B|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|U|3|V|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

<code>memset</code> sets bytes, so you get <code>double</code>-values where each byte is <code>-1</code>.

Instead in C++ use <code>std::vector</code>, then write

<pre><code>vector&lt;double&gt; dp( 505, -1.0 );
</code></pre>

It's that simple.

<hr>

If <code>dp</code> is a global vector and you need to set it to <code>-1</code> a number of times, then you can simply do this:

<pre><code>dp = vector&lt;double&gt;( dp.size(), -1.0 );
</code></pre>

However, it's <a href="https://softwareengineering.stackexchange.com/questions/148108/why-is-global-state-so-evil">generally not a good idea to use non-<code>const</code> global variables</a>.

<hr>

Alternatively one can use <code>std::fill</code>, or just a loop, or just about any technique that still treat the <code>double</code> values as <code>double</code> values. But <code>std::vector</code> is preferable also for many other reasons than greatly simplifying the fill-it task. In particular a <code>std::vector</code> can be resized, it takes care of copying, and it automates the memory management, doing that part correctly and transparent to you.

blocks|key|2909345|text|虽然已经给出了问题的答案，但我只想让您注意，sizeof(dp)输出用于在内存中编码变量的字节数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2909346|在您的例子中，dp是一个指向双变量的指针。然后，它将等于指针(4)的大小，无论是否已分配了内存。size+of+(*dp)输出的大小为双倍(8)。，以便使用|2909347|entityMap^0|M|A|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|$]]

Although answers for you question have been given, I just wanted you to note that 
 <code>sizeof(dp)</code>
outputs the number of bytes used to code the variable in memory.

In your case, dp is a pointer to a double. It will then be equal to the size of a pointer (4), no matter wether or not memery has been allocated.
sizeof(*dp) will output the size of a double (8).
In order to use the length of a

I want to set all the index value to <code>-1</code> in a double array. 
Here is my code :

<pre><code>double dp[505];
memset(dp,-1,sizeof(dp));
cout&lt;&lt;dp[0]&lt;&lt;"\n";
</code></pre>

But it is showing <code>nan</code> when i try to print its value. 

What does <code>nan</code> mean?
Is it possible to use <code>memset()</code> in double array?

using memset() in double type array

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我希望在一个双数组中将所有索引值设置为-1。这是我的代码：double dp[505];memset(dp,-1,sizeof(dp));cout<<dp[0]<<"\n";但是，当我试图打印它的值时，它正在显示nan。nan是什么意思？在双数组中可以使用memset()吗？

问在双类型数组中使用memset()
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在双类型数组中使用memset()EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在双类型数组中使用memset()
EN