4个回答
展开全部
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函数了。
#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++不支持直接构造 构造函数带参数的数组,也就是说如果你想要创建一个数组,必须要保证创建类型有默认的构造函数。
本回答被提问者采纳
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
展开全部
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函数了。
<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函数了。
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
展开全部
#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;
}
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;
}
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
推荐律师服务:
若未解决您的问题,请您详细描述您的问题,通过百度律临进行免费专业咨询