在c++中如何用new生成一个构造函数带参数的类数组?

Posted 2023-03-19

高手解答，最好举例！

1.代码如下：#include <iostream>
#include <new>
using namespace std;

class foo

public:
explicit foo( int id=0 ) : id_(id)

cout << __FUNCTION__ << " " << id_ << endl;

~foo()

cout << __FUNCTION__ << " " << id_ << endl;

private:
int id_;
;

int main()

int a[2] = 0, 1 ;

// 第一种方法

foo b[2] = foo(a[0]), foo(a[1]) ;


cout << "-----------------" << endl;

// 第二种方法

char _b_buf_[ sizeof(foo)*2 ];
foo (&b)[2] = (foo(&)[2])_b_buf_;
for( size_t i=0; i<2; ++i )

new(&b[i]) foo( a[i] );


// ...use b

for( size_t i=0; i<2; ++i )

b[2-1-i].~foo();



cout << "-----------------" << endl;

// 这估计就是你要的了，和第二种方法一样

foo* p = (foo*)operator new( sizeof(foo)*2 );
for( size_t i=0; i<2; ++i )

new(&p[i]) foo( (int)i );


// ...use b

for( size_t i=0; i<2; ++i )

p[2-1-i].~foo();

operator delete( p );


return 0;

2.C++ new用法之一 new运算符
最常用的是作为运算符的new，比如：
string *str = new string(“test new”);
作为运算符，new和sizeof一样，是C++内置的，你不能对它做任何的改变，除了使用它。
new会在堆上分配一块内存，并会自动调用类的构造函数。
C++ new用法之二 new函数
第二种就是new函数，其实new运算符内部分配内存使用的就是new函数，原型是：
void *operator new(size_t size);
new函数返回的是一个void指针，一块未经初始化的内存。如你所见，这和C语言的malloc行为相似，你可以重载new函数，并且增加额外的参数，但是必须保证第一个参数必须是size_t类型，它指明了分配内存块的大小，C++允许你这么做，当然一般情况下这是不必要的。如果重载了new函数，在使用new操作符时调用的就是你重载后的new函数了。 参考技术A C++不支持直接构造 构造函数带参数的数组，也就是说如果你想要创建一个数组，必须要保证创建类型有默认的构造函数。本回答被提问者采纳 参考技术B 1.代码如下：#include
<iostream>
#include
<new>
using
namespace
std;
class
foo

public:
explicit
foo(
int
id=0
)
:
id_(id)

cout
<<
__FUNCTION__
<<
"
"
<<
id_
<<
endl;

~foo()

cout
<<
__FUNCTION__
<<
"
"
<<
id_
<<
endl;

private:
int
id_;
;
int
main()

int
a[2]
=

0,
1
;
//
第一种方法

foo
b[2]
=

foo(a[0]),
foo(a[1])
;

cout
<<
"-----------------"
<<
endl;
//
第二种方法

char
_b_buf_[
sizeof(foo)*2
];
foo
(&b)[2]
=
(foo(&)[2])_b_buf_;
for(
size_t
i=0;
i<2;
++i
)

new(&b[i])
foo(
a[i]
);

//
...use
b
for(
size_t
i=0;
i<2;
++i
)

b[2-1-i].~foo();


cout
<<
"-----------------"
<<
endl;
//
这估计就是你要的了，和第二种方法一样

foo*
p
=
(foo*)operator
new(
sizeof(foo)*2
);
for(
size_t
i=0;
i<2;
++i
)

new(&p[i])
foo(
(int)i
);

//
...use
b
for(
size_t
i=0;
i<2;
++i
)

p[2-1-i].~foo();

operator
delete(
p
);

return
0;

2.C++
new用法之一
new运算符
最常用的是作为运算符的new，比如：
string
*str
=
new
string(“test
new”);
作为运算符，new和sizeof一样，是C++内置的，你不能对它做任何的改变，除了使用它。
new会在堆上分配一块内存，并会自动调用类的构造函数。
C++
new用法之二
new函数
第二种就是new函数，其实new运算符内部分配内存使用的就是new函数，原型是：
void
*operator
new(size_t
size);
new函数返回的是一个void指针，一块未经初始化的内存。如你所见，这和C语言的malloc行为相似，你可以重载new函数，并且增加额外的参数，但是必须保证第一个参数必须是size_t类型，它指明了分配内存块的大小，C++允许你这么做，当然一般情况下这是不必要的。如果重载了new函数，在使用new操作符时调用的就是你重载后的new函数了。 参考技术C #include <iostream>
using namespace std;

class A

public:
A(int a)i = a;
void print()cout << "i = " << i << endl;
private:
int i;
;
int main()

A *a[10];
for (int i = 0;i < 10;i++)
a[i] = new A(i);
return 0;

为啥我不能在 C++ 中用 new 调用参数化构造函数？

【中文标题】为啥我不能在 C++ 中用 new 调用参数化构造函数？

【英文标题】：Why can't I call a parameterized constructor with new in c++?为什么我不能在 C++ 中用 new 调用参数化构造函数？

【发布时间】：2011-02-21 20:41:54

【问题描述】：

如果你知道问题，

假设我有一个类 A，它的 CTOR 接收一个整数；

我无法做到以下几点：

A* arr = new A[3](A(2), A(3), A(5));

或任何其他方式来初始化数组的多个成员。 我读了一遍，这是不可能的。

我的问题是为什么，为什么我可以这样做

A arr[3] = A(1), A(2), A(3);

但我不能做到以上？记忆方面的或其他的。

非常感谢！

【问题讨论】：

这些是不同的东西。虽然能够做到这样的事情是有道理的，但我确信这是 C 的一些遗留问题，出于某种原因 C++ 只是“不得不”用

【参考方案1】：

在当前标准 C++（称为 C++03）中不能这样做的原因是历史性的。这将在即将发布的 C++ 标准（目前预计将于今年发布，这将使其成为 C++11）中得到清理，该标准将引入所谓的“统一初始化语法”。

根据Stroustrup's C++0x FAQ，可以接着写

A* p = new A[3] A(1), A(2), A(3);

很有可能您的编译器实际上已经支持这一点。

【讨论】：

统一初始化语法也适用于 new[]？

@Thomas：根据www2.research.att.com/~bs/C++0xFAQ.html#uniform-init，确实如此。

有趣。虽然您需要在上面的示例中添加 [] 以匹配问题。

@Thomas：是的，FredO 刚刚在聊天中说服我这样做了……事实上，在真正阅读那个 FAQ 条目之后（而不是仅仅浏览它) 他似乎对动态数组只字未提。 <sigh/> 不管怎样，Fred 发现 GCC 支持这种语法，所以这就是我目前抓住的稻草......

N2215（链接自 BS 的常见问题解答）在第 5 页使用 new int[]1, 2, 3。我还没有在那篇论文中弄清楚它的语义，但我在 N3225 中找不到任何关于它的信息§ 5.3.4 超出该语法允许的语法。

【参考方案2】：

我相信您正在尝试执行 C++0x 中包含的“统一初始化”。我不明白为什么初始化列表使用A(int) 部分，我只是这样做（C++98/03 接受：

A arr[3] = 1, 2, 3;

【讨论】：

如果A 是一个具有explicit 构造函数的类，该构造函数采用int，则必须显式调用它进行转换：A(42)。我更喜欢在默认情况下使所有单参数构造函数显式，并且很少偏离。事实上，回顾超过 15 年的 C++，我使用了频率不断降低的隐式转换。原因之一是我不得不回到旧代码并删除它，通常会非常痛苦（需要调整大量代码），因为它会在意想不到的时间出现问题。