The Big Programming Thread - Page 473

// Method 1

for(int i = 1; i <= 10; i++)
{
    mRectanglePack.Add(new Rectangle(1, i));
}

void RectanglePack::Add(Rectangle* rectangle)
{
    mRectangleVector.push_back(rectangle) // this vector stores Rectangle pointers
}

// Method 2

for(int i = 1; i <= 10; i++)
{
    Rectangle rectangle(1, i)
    mRectanglePack.Add(rectangle);
}

void RectanglePack::Add(Rectangle rectangle)
{
    mRectangleVector.push_back(rectangle) // this vector stores Rectangle objects
}

// Method 3

for(int i = 1; i <= 10; i++)
{
    Rectangle rectangle = new Rectangle(1, i)
    mRectanglePack.Add(*rectangle);
}

or(int i = 1; i <= 10; i++)
{
    Rectangle rectangle(1, i)
    mRectanglePack.Add(&rectangle);
}

#include<iostream>
#include<vector>
#include<utility>

using namespace std;

struct imba_t{
	imba_t(){ std::cout<<"def ctor\n"; }
	imba_t(imba_t const&){ std::cout<<"cpy ctor\n"; }
	imba_t(imba_t&&){ std::cout<<"mov ctor\n"; }
};

class protoss_t{
	vector<imba_t> death_ball;
public:
	protoss_t(){ death_ball.reserve(5); } //reserve some space
	void ref_add(imba_t const& unit){ death_ball.push_back(unit); }
	void mov_add(imba_t&& unit){ death_ball.push_back(std::move(unit)); }
	void cpy_add(imba_t unit){ death_ball.push_back(unit); }
};

int main(){
	protoss_t protoss;
	imba_t zealot;
	std::cout<<"\npassing imba unit by const ref\n";
	protoss.ref_add(zealot);
	std::cout<<"passing imba unit by rvalue ref\n";
	protoss.mov_add(imba_t());
	imba_t sentry;
	std::cout<<"\npassing imba unit by value\n";
	protoss.cpy_add(sentry);
}

[jeh@gimli tl]$ ./tl 
def ctor <- zealot contructed
passing imba unit by const ref
cpy ctor
passing imba unit by rvalue ref
def ctor <-unnamed imba_t constructed
mov ctor
def ctor <- sentry constructed
passing imba unit by value
cpy ctor
cpy ctor

#include<iostream>
#include<memory>
#include<vector>
#include<utility>

using namespace std;

struct imba_t{
	imba_t(){ std::cout<<"def ctor\n"; }
	imba_t(imba_t const&){ std::cout<<"cpy ctor\n"; }
	imba_t(imba_t&&){ std::cout<<"mov ctor\n"; }
	~imba_t(){ std::cout<<"dtor\n"; }
};

typedef shared_ptr<imba_t> imba_ptr_t;

class protoss_t{
	vector<imba_ptr_t> death_ball;
public:
	protoss_t(){ death_ball.reserve(5); }
	void add(imba_ptr_t const& unit){ std::cout<<"cpy ptr\n"; death_ball.push_back(unit); }
	void add(imba_ptr_t&& unit){ std::cout<<"mov ptr\n"; death_ball.push_back(std::move(unit)); }
};

int main(){
	imba_ptr_t zealot=make_shared<imba_t>();
	{
		protoss_t protoss;
		std::cout<<"passing imba unit by const ref\n";
		protoss.add(zealot);
		std::cout<<"passing imba unit by rvalue ref\n";
		protoss.add(make_shared<imba_t>());
		std::cout<<"passing imba unit by value\n";
	}
	std::cout<<"protoss gone, zealot still here\n";
}

[jeh@gimli tl]$ ./tl 
def ctor
passing imba unit by const ref
cpy ptr
passing imba unit by rvalue ref
def ctor
mov ptr
passing imba unit by value
dtor <- unnamed imba_t destructed
protoss gone, zealot still here
dtor <- zealot destructed

	vector<imba_t> death_ball;
	int N=10;
	death_ball.reserve(N);
	for(int i=0;i<N;++i) death_ball.emplace_back(i);

	vector<imba_t> death_ball({{0,'b'},{1,'c'},{2,'f'}});

	int i=0,N=10;
	vector<imba_t> death_ball; 
	generate_n(begin(death_ball),N,[&](){
		return ++i;
	});

Add(new Rectangle)

Add(*rectangle)

Add(rectangle)

Text. <script> whatever text </script> More text.

Text. More text.

String#replaceAll("\\<[^>]*>","")