最近，我遇到了对new运算符的异常使用，以重新初始化C ++类，其代码如下：
#include <iostream>
struct Test { Test() { std::cout<<"Test Ctor\n"; } };
int main()
{
Test t ;
new (&t) Test;
return 0 ;
}
如果运行此代码，则会两次调用Test ctor。在这种情况下，似乎“ new”运算符正在使用指向对象的指针作为内存源，而不是分配新内存，valgrind确认没有内存泄漏。
有人可以阐明“新”运算符的用法吗？
假设我有一个超载的类operator new.
class Class {
public:
void* operator new( size_t );
void operator delete( void* );
};
operator new当我使用时,该类的对象是否总是与重载一起分配,new Class()或者operator new当new Class()构造出现在代码中时是否可能使用默认值？
最近我读了一段这样的代码:
template <unsigned long size>
class FooBase
{
bool m_bValid;
char m_data[size];
};
template <class T>
class Foo : public FooBase<sizeof(T)>
{
// it's constructor
Foo(){};
Foo(T const & t) {construct(t); m_bValid = (true);}
T const * const GetT() const { return reinterpret_cast<T const * const>(m_data); }
T * const GetT() { return reinterpret_cast<T * const>(m_data);}
// could anyone help me understand this line??
void construct(T const & t) {new (GetT()) T(t);}
};
我已经对代码进行了切片以确保它并不复杂,主要问题是关于construct(T const & t)函数.
什么 …
make_shared为对象和引用计数器分配单个块.因此使用这种技术有明显的性能优势.
我在VS2012进行了简单的实验,我正在寻找"证据":
std::shared_ptr<Test> sp2 = std::make_shared<Test>();
std::shared_ptr<Test> sp(new Test());
// Test is a simple class with int 'm_value' member
调试时我在本地查看这样的东西(删除了一些行)
- sp2 shared_ptr {m_value=0 } [make_shared] std::shared_ptr<Test>
+ _Ptr 0x01208dec {m_value=0 } Test *
+ _Rep 0x01208de0 make_shared std::_Ref_count_base *
- sp shared_ptr {m_value=0 } [default] std::shared_ptr<Test>
+ _Ptr 0x01203c50 {m_value=0 } Test *
+ _Rep 0x01208d90 default std::_Ref_count_base *
似乎sp2在0x01208de0(有一个ref计数器)中分配,然后在0x01208dec中有一个Test对象.地点彼此非常接近.
在第二个版本中,我们有0x01208d90为参考计数器,0x01203c50的对象.那些地方相当遥远.
这是正确的输出吗？我能正确理解吗？
标准定义我们可以通过以下方式使用std :: memcpy:
对于任何简单的可复制类型T,如果指向T的两个指针指向不同的T对象obj1和obj2,其中obj1和obj2都不是基类子对象,如果构成obj1的基础字节(1.7)被复制到obj2中,obj2将随后保持与obj1相同的值.
如果我们将该函数应用于非平凡可复制类型的对象,我们可能会遇到什么样的潜在问题？以下代码的工作原理就好像它适用于普通可复制类型:
#include <iostream>
#include <cstring>
using std::cout;
using std::endl;
struct X
{
int a = 6;
X(){ }
X(const X&)
{
cout << "X()" << endl;
}
};
X a;
X b;
int main()
{
a.a = 10;
std::memcpy(&b, &a, sizeof(X));
cout << b.a << endl; //10
}
我试图通过编写一组管理动态数组的过程来学习 Ada，但我不知道如何去做。在 C++ 中，我可以轻松地将任意对象放入内存中，如下所示：
#include <new>
#include <iostream>
class object {
private:
int value;
public:
~object() noexcept { std::cout << "<> "; }
object(int value) noexcept : value(value) { std::cout << object::value << ' '; }
};
constexpr auto size = 16;
int main() {
auto buffer = static_cast<object*>(::operator new(size * sizeof(object)));
for (auto offset = 0; offset < size; offset++)
new (buffer + offset) object(offset);
for (auto offset = 0; offset < size; offset++)
(buffer + offset)->~object();
::operator delete(buffer); …在我的代码中,我有:
#define EV( event ) SendEvent( new event );
EV( evFormat );
但我想在EV宏中传递一个创建的对象,如:
CEvent *ev = new CEvent();
EV( ev );
这可能吗？因为我无法修改EV宏.
所以考虑到这个c结构:
typedef struct {
int* arr1;
int* arr2;
} myStruct;
这个答案描述了使用单个malloc来同时分配a myStruct和它的数组:
myStruct* p = malloc(sizeof(*p) + 10 * sizeof(*p->arr1) + 10 * num * sizeof(*p->arr2);
if(p != NULL) {
p->arr1 = (int*)(p + 1);
p->arr2 = p->arr1 + 10;
}
我想知道有没有类似的方法来做到这一点new？
显然,我希望能够分配到我在运行时收到的大小,就像使用C示例一样.
我正在学习c ++,并想知道这样的程序是如何组织在主存储器中的.我知道有一个堆栈(带有堆栈框架)和一个堆.我知道动态分配的东西会在堆上分配它.这是由像malloc或的运营商完成的new.但我不能在这个小型的c ++程序中看到它们.
该程序由一个主类和一个名为的类组成MyClass.这堂课有:
int)main类定义了一个Myclass对象,并定义了一个指向该对象的指针.
那么 - 这一切如何在记忆中组织起来？
#include <iostream>
using namespace std;
class MyClass {
int i;
public:
MyClass(int n) {
i = n;
}
int get_nmbr() {
return this->i;
}
};
int main() {
MyClass myClass(100), *p;
cout << myClass.get_nmbr() << endl;
p = &myClass;
cout << p;
return 0;
}