9. insert vs emplace vs push

#include<vector>

using namespace std;

class Point {

public:
	int x, y;
	Point() :x(0), y(0) {}
	Point(int x, int y) : x(x), y(y) {}
};

int main() {
	vector<Point> v;

	Point p1{ 10,10 };
	Point p2{ 20,20 };

	v.insert(v.end(), p1);						// 기존에 존재하는 요소를 삽입
	v.insert(v.end(), Point(1,1));				// 새로 요소를 생성하면서 삽입
	v.insert(v.end(), {2,3});					// list-initializer를 이용한 생성 후 삽입
	v.insert(v.end(), {p1, p2});				// 여러 개의 요소를 list-initialier로 묶어서 삽입
	v.insert(v.end(), { Point(), Point(1,1)});	// 생성과 동시에 삽입 가능
	v.insert(v.end(), { {4,5},{3,2} });			// 생성과 동시에 삽입 가능
	v.insert(v.end(), 5, p1);					// 동일한 요소롤 반복 추가 가능
	//v.insert(v.end(), 3,3);					// 알 수 없는 잘못된 삽입 연산

	v.push_back(p1);							// 기존에 존재하는 요소를 삽입
	v.push_back(Point(1, 1));					// 새로 요소를 생성하면서 삽입
	v.push_back({ 2,3 });						// list-initializer를 이용한 생성 후 삽입
	//v.push_back({ p1, p2 });					// 여러 개의 요소를 삽입할 수 없다.
	//v.push_back(4, 5);						// 알 수 없는 잘못된 삽입 연산

	v.emplace(v.end(), 1, 2);					// Point(1,2)를 내부에서 생성함.
	v.emplace(v.end());							// Point()를 내부에서 생성함.
	v.emplace(v.end(), p1);						// 복사 생성자를 호출
	v.emplace(v.end(), Point(1, 1));			// 복사 생성자 호출
	// v.emplace(v.end(), {p1,p2});				// 여러 개의 요소 생성 불가능.
}

#include <iostream>
#include <vector>
#include <chrono>

class LargeMemoryBlock {
public:
    LargeMemoryBlock(size_t size) 
    : data(new int[size]), size(size) {
        // Simulate expensive resource allocation
        for (size_t i = 0; i < size; ++i) {
            data[i] = i;
        }
    }

    LargeMemoryBlock(const LargeMemoryBlock& other) 
    : data(new int[other.size]), size(other.size) {
        //std::cout << "Copy constructor" << std::endl;
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    LargeMemoryBlock(LargeMemoryBlock&& other) noexcept 
    : data(other.data), size(other.size) {
        //std::cout << "Move constructor" << std::endl;
        other.data = nullptr;
        other.size = 0;
    }

    ~LargeMemoryBlock() {
        delete[] data;
    }

private:
    int* data;
    size_t size;
};

int main() {
    const int numObjects = 10000;
    const size_t blockSize = 10000;  // 4 MB
    const int N = 10;

    std::vector<LargeMemoryBlock> vecCopy;
    std::vector<LargeMemoryBlock> vecMove;

    // Benchmark push_back() with LargeMemoryBlock
    for (int t = 0; t < N; t++) {
        auto start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < numObjects; ++i) {
            vecCopy.push_back(LargeMemoryBlock(blockSize));
        }
        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> pushBackCopyTime = end - start;
        std::cout << "push_back() with LargeMemoryBlock time: " << pushBackCopyTime.count() << " seconds" << std::endl;

        // Benchmark emplace_back() with LargeMemoryBlock
        start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < numObjects; ++i) {
            vecMove.emplace_back(blockSize);
        }
        end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> emplaceBackMoveTime = end - start;
        std::cout << "emplace_back() with LargeMemoryBlock time: " << emplaceBackMoveTime.count() << " seconds" << std::endl;
    }
    return 0;
}