void foo(void)
{
std::cout << std::endl;
// It will use a default deleteter: delete operator
std::shared_ptr<Test> ptr1 = std::make_shared<Test>("FT");
// this will use a user defined deleter
std::shared_ptr<Test> ptr2 = std::shared_ptr<Test>(new Test("ST"), [](Test *t) { std::cout << "user defined deleter "; delete t; });
// this code will cause a memory leak, (abortion)
// Test[1] and Test[2] will not be deleted
// std::shared_ptr<Test> ptr3(new Test[3]);
// solution is to provide a user defined deleter
std::shared_ptr<Test> ptr4(new Test[3], [](Test *t) { delete[]t; });
// get() returns a RAW pointer
// 1. Test *p = ptr4.get(); delete p; -> undefined
// 2. std::shared_ptr<Test> pt5(p); -> undefined
// causes double free of an object
ptr1.get();
}
void testObj::test<10>(void)
{
PointerWrapper< boost::shared_ptr<Data> > ptr(sp_);
PointerWrapper< boost::shared_ptr<Data> > ptr1(ptr);
PointerWrapper< boost::shared_ptr<const Data> > ptr2(ptr);
PointerWrapper<Data*> ptr3(ptr);
PointerWrapper<const Data*> ptr4(ptr);
}
void testObj::test<9>(void)
{
PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr(spnn_);
PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr1(ptr);
PointerWrapper< Commons::SharedPtrNotNULL<const Data> > ptr2(ptr);
PointerWrapper< boost::shared_ptr<Data> > ptr3(ptr);
PointerWrapper< boost::shared_ptr<const Data> > ptr4(ptr);
PointerWrapper<Data*> ptr5(ptr);
PointerWrapper<const Data*> ptr6(ptr);
}
// Test the gmGCRoot system
void TestGMGCRoot()
{
gmGCRootManager::Init(); // Init system
{
gmMachine machine1;
gmGCRoot<gmStringObject> ptr1;
gmStringObject* stringObj1 = machine1.AllocStringObject("hello");
ptr1.Set(stringObj1, &machine1); // Initialize via func
gmStringObject* nat1 = ptr1; // Assign pointer
gmGCRoot<gmStringObject> ptr2;
ptr2 = ptr1;
ptr1 = NULL; // Assign to null
ptr2 = NULL;
//ptr2 = nat1; // ERROR
gmStringObject* stringObj2 = machine1.AllocStringObject("apple");
gmGCRoot<gmStringObject> ptr3(stringObj2, &machine1); // Initialize via constructor
gmGCRoot<gmStringObject> ptr4(stringObj2, &machine1); // Duplicate without copy
gmGCRoot<gmStringObject> ptr5;
{
gmMachine machine2;
gmStringObject* stringObj3 = machine2.AllocStringObject("bannana");
ptr5.Set(stringObj3, &machine2);
gmGCRootManager::Get()->DestroyMachine(&machine2); // Null associated pointers
}
if( ptr5 )
{
int i=1; // Won't get here
}
}
gmGCRootManager::Destroy();
}
TEST(fxcrt, MaybeOwnedMove) {
int delete_count = 0;
PseudoDeletable thing1(100, &delete_count);
{
CFX_MaybeOwned<PseudoDeletable> ptr1(&thing1);
CFX_MaybeOwned<PseudoDeletable> ptr2(
pdfium::MakeUnique<PseudoDeletable>(200, &delete_count));
EXPECT_FALSE(ptr1.IsOwned());
EXPECT_TRUE(ptr2.IsOwned());
CFX_MaybeOwned<PseudoDeletable> ptr3(std::move(ptr1));
CFX_MaybeOwned<PseudoDeletable> ptr4(std::move(ptr2));
EXPECT_FALSE(ptr1.IsOwned());
EXPECT_FALSE(ptr2.IsOwned());
EXPECT_FALSE(ptr3.IsOwned());
EXPECT_TRUE(ptr4.IsOwned());
EXPECT_EQ(0, delete_count);
EXPECT_EQ(nullptr, ptr1.Get());
EXPECT_EQ(nullptr, ptr2.Get());
EXPECT_EQ(100, ptr3->GetID());
EXPECT_EQ(200, ptr4->GetID());
CFX_MaybeOwned<PseudoDeletable> ptr5;
CFX_MaybeOwned<PseudoDeletable> ptr6;
ptr5 = std::move(ptr3);
ptr6 = std::move(ptr4);
EXPECT_FALSE(ptr3.IsOwned());
EXPECT_FALSE(ptr4.IsOwned());
EXPECT_FALSE(ptr5.IsOwned());
EXPECT_TRUE(ptr6.IsOwned());
EXPECT_EQ(0, delete_count);
EXPECT_EQ(nullptr, ptr3.Get());
EXPECT_EQ(nullptr, ptr4.Get());
EXPECT_EQ(100, ptr5->GetID());
EXPECT_EQ(200, ptr6->GetID());
}
EXPECT_EQ(1, delete_count);
}
FourTree::FourTree(int maxObjects, int maxLevels, sf::FloatRect bounds, int currentLevel)
:mMaxLevels(maxLevels),
mMaxObjects(maxObjects),
mBounds(bounds),
mCurrentLevel(currentLevel),
isSpilt(false),
mWorldLocation(0.f, 0.f)
{
for (int i = 0; i < LocationCount; i++)
mNodes[i] = NULL;
if (mCurrentLevel < mMaxLevels){
float subWidth = mBounds.width / 2;
float subHeight = mBounds.height / 2;
float x = mBounds.left;
float y = mBounds.top;
//top right
FourTree::Ptr ptr1(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x + subWidth, y, subWidth, subHeight), mCurrentLevel + 1));
//top left
FourTree::Ptr ptr2(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x, y, subWidth, subHeight), mCurrentLevel + 1));
//bottom left
FourTree::Ptr ptr3(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x, y + subHeight, subWidth, subHeight), mCurrentLevel + 1));
//bottom right
FourTree::Ptr ptr4(new FourTree(maxObjects, maxLevels,
sf::FloatRect(x + subWidth, y + subHeight, subWidth, subHeight), mCurrentLevel + 1));
mNodes[Top_Right] = std::move(ptr1);
mNodes[Top_Left] = std::move(ptr2);
mNodes[Bottom_Left] = std::move(ptr3);
mNodes[Bottom_Right] = std::move(ptr4);
}
}
