blocks|key|391398|text|B*+B_array[1000];|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|391399|您所拥有的是指向类型1000的一个B指针数组。|unstyled|offset|length|style|CODE|391400|++for(int+i+=+0;+i+<+1000;+i%2B%2B)
++{
+++++++B_array[i]+=+new+B;//can+i+use+B_array[0...999]???
++}|391401|将内存分配给数组中的每个指针，在此语句之后，每个指针指向堆上的内存。|391402|因此，是的，一旦执行了这些代码，您就可以使用它们中的每一个。|391403|entityMap^0|0|A|4|H|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]|$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>B* B_array[1000];
</code></pre>

What you have is an array of <code>1000</code> pointers to the type <code>B</code>.

<pre><code> for(int i = 0; i &lt; 1000; i++)
 {
 B_array[i] = new B;//can i use B_array[0...999]???
 }
</code></pre>

Allocates memory to each pointer in the array, after this statement each pointer points to a memory on heap. 

So yes you can use each of them, once this code is executed.

blocks|key|4671141|text|是的你可以。将始终为1000个指针分配内存。然而，这些指针不会被初始化，除非你自己去做(就像你在你的构造代码中一样)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4671142|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|$]]

Yes you can. Memory for 1000 pointers will be allocated always. However those pointers will not be initialised unless you do that yourself (as you are in your contructor code).

blocks|key|56044|text|可以，停那儿吧。当您输入构造函数的主体时，有1000个未初始化的指针等待您初始化它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56045|不过，您应该做的是使用std::vector|offset|length|style|CODE|56046|class+A
{
++public:
+++++std::vector+array;
}

A::A()+:+array(1000)+{}|code-block|syntax|javascript|56047|做完这件事。向量动态分配其元素。|56048|entityMap^0|0|B|E|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Yes, you can. When you enter the body of constructor, there are 1000 uninitialized pointers waiting for you to initialize them.

What you should do, though, is use <code>std::vector&lt;B&gt;</code>

<pre><code>class A
{
 public:
 std::vector&lt;B&gt; array;
}

A::A() : array(1000) {}
</code></pre>

and be done with it. Vector allocates its elements dynamically.

blocks|key|56062|text|我想知道是否在c%2B%2B中为类的数组成员分配内存|type|blockquote|depth|inlineStyleRanges|entityRanges|data|56063|unstyled|56064|是的，为什么不呢。如果你对分配数组的方式有疑问，那是有可能的。如果你对在A的构造函数中调用B的构造函数有疑问，那么这也是绝对没有问题的。|56065|一般来说，在代码中有几件我会注意的，例如不要硬编码值1000，检查新的异常等等。你知道这个主意。|56066|此外，您还应该为显式地释放A的析构函数中的内存资源而烦恼。|56067|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|C|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|C|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|C|7|Q|8|@]|9|@]|A|$]]]|K|$]]

<blockquote>
 <blockquote>
 I wonder whether memory for array member of a class be allocated in c++
 </blockquote>
</blockquote>

Yes, why not. If your doubt is about allocating an array the way you are doing, it is possible. If your doubt is about calling B's constructor while still being in A's constructor, then also there is absolutely no issues with that.

In general, however there are several things that I would take care in the code shown e.g. not hard coding the value 1000, checking for exception from new etc.. you get the idea.

And you should also be bothered about releasing the memory resource in the destructor of A explicitly.

blocks|key|56106|text|是的，将为B类实例的1000个指针分配内存。您已经定义了一个B_array[1000]数组的B*对象。它和int+integerArray+[1000]一样。您只是将指针存储在数组中，而不是值中。但是，您需要初始化它们以指向堆中的实际对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|56107|entityMap^0|U|D|1A|2|1H|N|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

Yes, the memory for 1000 pointers of B class instances will be allocated. You have defined an array <code>B_array[1000]</code> of <code>B*</code> objects. It's the same as <code>int integerArray [1000]</code>. You just store pointers in the array, not values.
However you will need to initialize them to point to the actual objects on the heap.

I wonder whether memory for array member of a class be allocated in c++. 
In my class, I defined array member like this: 

<pre><code>class A
{
 public:
 B* B_array[1000];
}
</code></pre>

and, in the constructor, I want to use it: 

<pre><code>A::A()
{
 for(int i = 0; i &lt; 1000; i++)
 {
 B_array[i] = new B;//can i use B_array[0...999]???
 }
}
</code></pre>

Will memory of array member of a class be allocated?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想知道是否在c++中为类的数组成员分配内存。在我的类中，我定义了如下数组成员：class A{ public: B* B_array[1000];}在构造函数中，我想使用它：A::A(){ for(int i = 0; i < 1000; i++) { B_array[i] = new B;//c...

问会分配类数组成员的内存吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问会分配类数组成员的内存吗？EN