[deque] fix: copy_construct_impl source pointer, emplace_decision::po…

include/fast_io_dsal/impl/deque.h

@@ -2228,7 +2228,7 @@ class deque FAST_IO_TRIVIALLY_RELOCATABLE_IF_ELIGIBLE
 			pointer lastblockbegin;
 			if (front_controller_ptr == back_controller_ptr)
 			{
-				lastblockbegin = controller.front_block.curr_ptr;
+				lastblockbegin = fromcontroller.front_block.curr_ptr;
 			}
 			else
 			{
@@ -2342,7 +2342,12 @@ class deque FAST_IO_TRIVIALLY_RELOCATABLE_IF_ELIGIBLE
 	}
 
 	inline explicit constexpr deque(size_type n, const_reference val) noexcept(::std::is_nothrow_copy_constructible_v<value_type>)
+		: controller{}
 	{
+		if (!n)
+		{
+			return;
+		}
 		if constexpr (::std::is_nothrow_copy_constructible_v<value_type>)
 		{
 			this->reserve_back(n);
@@ -3303,7 +3308,7 @@ class deque FAST_IO_TRIVIALLY_RELOCATABLE_IF_ELIGIBLE
 
 	struct emplace_decision
 	{
-		::std::size_t pos;
+		iterator pos;
 		::std::int_fast8_t decision;
 	};
 	template <bool isnothrow>

tests/0026.container/0003.deque/access.cc

@@ -0,0 +1,145 @@
+#include <fast_io.h>
+#include <fast_io_dsal/deque.h>
+#include <deque>
+
+namespace
+{
+
+inline void test_operator_subscript()
+{
+	::fast_io::io::perr("=== deque operator[] test ===\n");
+
+	::fast_io::deque<::std::size_t> dq;
+	::std::deque<::std::size_t> ref;
+
+	// Fill with data
+	for (::std::size_t i{}; i != 4096u; ++i)
+	{
+		dq.push_back(i);
+		ref.push_back(i);
+	}
+
+	// Test operator[] (non-const)
+	for (::std::size_t i{}; i != dq.size(); ++i)
+	{
+		if (dq[i] != ref[i])
+		{
+			::fast_io::io::panicln("operator[] mismatch at ", i);
+		}
+	}
+
+	// Test operator[] (const)
+	{
+		auto const &cdq = dq;
+		for (::std::size_t i{}; i != cdq.size(); ++i)
+		{
+			if (cdq[i] != ref[i])
+			{
+				::fast_io::io::panicln("const operator[] mismatch at ", i);
+			}
+		}
+	}
+
+	// Test index_unchecked
+	for (::std::size_t i{}; i != dq.size(); ++i)
+	{
+		if (dq.index_unchecked(i) != ref[i])
+		{
+			::fast_io::io::panicln("index_unchecked mismatch at ", i);
+		}
+	}
+
+	// Modify via operator[] and verify
+	for (::std::size_t i{}; i != dq.size(); ++i)
+	{
+		dq[i] = i * 2u;
+		ref[i] = i * 2u;
+	}
+
+	for (::std::size_t i{}; i != dq.size(); ++i)
+	{
+		if (dq[i] != ref[i])
+		{
+			::fast_io::io::panicln("operator[] modification mismatch at ", i);
+		}
+	}
+
+	::fast_io::io::print("deque operator[] test finished\n");
+}
+
+inline void test_front_back()
+{
+	::fast_io::io::perr("=== deque front() / back() test ===\n");
+
+	::fast_io::deque<::std::size_t> dq;
+	::std::deque<::std::size_t> ref;
+
+	for (::std::size_t i{}; i != 4096u; ++i)
+	{
+		dq.push_back(i);
+		ref.push_back(i);
+	}
+
+	// front() and back() (non-const)
+	if (dq.front() != ref.front())
+	{
+		::fast_io::io::panic("front() mismatch\n");
+	}
+
+	if (dq.back() != ref.back())
+	{
+		::fast_io::io::panic("back() mismatch\n");
+	}
+
+	// front() and back() (const)
+	{
+		auto const &cdq = dq;
+		if (cdq.front() != ref.front())
+		{
+			::fast_io::io::panic("const front() mismatch\n");
+		}
+
+		if (cdq.back() != ref.back())
+		{
+			::fast_io::io::panic("const back() mismatch\n");
+		}
+	}
+
+	// front_unchecked and back_unchecked
+	if (dq.front_unchecked() != ref.front())
+	{
+		::fast_io::io::panic("front_unchecked() mismatch\n");
+	}
+
+	if (dq.back_unchecked() != ref.back())
+	{
+		::fast_io::io::panic("back_unchecked() mismatch\n");
+	}
+
+	// Modify and verify
+	dq.front() = 9999u;
+	ref.front() = 9999u;
+
+	if (dq.front() != ref.front())
+	{
+		::fast_io::io::panic("front() modification mismatch\n");
+	}
+
+	dq.back() = 8888u;
+	ref.back() = 8888u;
+
+	if (dq.back() != ref.back())
+	{
+		::fast_io::io::panic("back() modification mismatch\n");
+	}
+
+	::fast_io::io::print("deque front() / back() test finished\n");
+}
+
+} // namespace
+
+int main()
+{
+	test_operator_subscript();
+	test_front_back();
+}

tests/0026.container/0003.deque/algorithm.cc

@@ -0,0 +1,204 @@
+#include <fast_io.h>
+#include <fast_io_dsal/deque.h>
+#include <deque>
+#include <algorithm>
+#include <vector>
+
+namespace
+{
+
+inline void test_copy()
+{
+	::fast_io::io::perr("=== deque std::copy test ===\n");
+
+	// Test sizes at and around block boundaries
+	::std::size_t const sizes[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+
+	for (::std::size_t n : sizes)
+	{
+		::fast_io::deque<::std::size_t> src;
+		::fast_io::deque<::std::size_t> dst;
+
+		for (::std::size_t i{}; i != n; ++i)
+		{
+			src.push_back(i);
+			dst.push_back(0u);
+		}
+
+		auto result = ::std::copy(src.cbegin(), src.cend(), dst.begin());
+		if (result != dst.end())
+		{
+			::fast_io::io::panicln("copy result not at end for n=", n);
+		}
+
+		for (::std::size_t i{}; i != n; ++i)
+		{
+			if (dst[i] != src[i])
+			{
+				::fast_io::io::panicln("copy value mismatch at ", i, " for n=", n);
+			}
+		}
+	}
+
+	// Compare with std::deque
+	{
+		::fast_io::deque<::std::size_t> fsrc, fdst;
+		::std::deque<::std::size_t> ssrc, sdst;
+
+		for (::std::size_t i{}; i != 4096u; ++i)
+		{
+			fsrc.push_back(i);
+			fdst.push_back(0u);
+			ssrc.push_back(i);
+			sdst.push_back(0);
+		}
+
+		::std::copy(fsrc.cbegin(), fsrc.cend(), fdst.begin());
+		::std::copy(ssrc.cbegin(), ssrc.cend(), sdst.begin());
+
+		for (::std::size_t i{}; i != 4096u; ++i)
+		{
+			if (fdst[i] != sdst[i])
+			{
+				::fast_io::io::panicln("copy mismatch with std::deque at ", i);
+			}
+		}
+	}
+
+	::fast_io::io::print("deque std::copy test finished\n");
+}
+
+inline void test_copy_backward()
+{
+	::fast_io::io::perr("=== deque std::copy_backward test ===\n");
+
+	{
+		::fast_io::deque<::std::size_t> dq;
+		for (::std::size_t i{}; i != 100u; ++i)
+		{
+			dq.push_back(i);
+		}
+
+		dq.resize(110u);
+		::std::copy_backward(dq.cbegin(), dq.cbegin() + 100, dq.end());
+
+		// First 10 elements unchanged (still 0..9)
+		for (::std::size_t i{}; i != 10u; ++i)
+		{
+			if (dq[i] != i)
+			{
+				::fast_io::io::panicln("copy_backward: first elements wrong at ", i);
+			}
+		}
+		for (::std::size_t i{}; i != 100u; ++i)
+		{
+			if (dq[i + 10u] != i)
+			{
+				::fast_io::io::panicln("copy_backward: shifted elements wrong at ", i);
+			}
+		}
+	}
+
+	// Compare with std::deque
+	{
+		::fast_io::deque<::std::size_t> fdq;
+		::std::deque<::std::size_t> sdq;
+
+		for (::std::size_t i{}; i != 100u; ++i)
+		{
+			fdq.push_back(i);
+			sdq.push_back(i);
+		}
+
+		fdq.resize(110u);
+		sdq.resize(110);
+		::std::copy_backward(fdq.cbegin(), fdq.cbegin() + 100, fdq.end());
+		::std::copy_backward(sdq.cbegin(), sdq.cbegin() + 100, sdq.end());
+
+		for (::std::size_t i{}; i != 110u; ++i)
+		{
+			if (fdq[i] != sdq[i])
+			{
+				::fast_io::io::panicln("copy_backward mismatch with std::deque at ", i);
+			}
+		}
+	}
+
+	::fast_io::io::print("deque std::copy_backward test finished\n");
+}
+
+inline void test_move()
+{
+	::fast_io::io::perr("=== deque std::move test ===\n");
+
+	::std::size_t const sizes[] = {0, 1, 2, 3, 1023, 1024, 1025, 2047, 2048, 2049};
+
+	for (::std::size_t n : sizes)
+	{
+		::fast_io::deque<::std::size_t> src;
+		::fast_io::deque<::std::size_t> dst;
+
+		for (::std::size_t i{}; i != n; ++i)
+		{
+			src.push_back(i);
+			dst.push_back(0u);
+		}
+
+		auto result = ::std::move(src.begin(), src.end(), dst.begin());
+		if (result != dst.end())
+		{
+			::fast_io::io::panicln("move result not at end for n=", n);
+		}
+
+		for (::std::size_t i{}; i != n; ++i)
+		{
+			if (dst[i] != i)
+			{
+				::fast_io::io::panicln("move value mismatch at ", i, " for n=", n);
+			}
+		}
+	}
+
+	::fast_io::io::print("deque std::move test finished\n");
+}
+
+inline void test_move_backward()
+{
+	::fast_io::io::perr("=== deque std::move_backward test ===\n");
+
+	::fast_io::deque<::std::size_t> dq;
+	for (::std::size_t i{}; i != 100u; ++i)
+	{
+		dq.push_back(i);
+	}
+
+	dq.resize(110u);
+	::std::move_backward(dq.begin(), dq.begin() + 100, dq.end());
+
+	for (::std::size_t i{}; i != 10u; ++i)
+	{
+		if (dq[i] != i)
+		{
+			::fast_io::io::panicln("move_backward: first elements wrong at ", i);
+		}
+	}
+	for (::std::size_t i{}; i != 100u; ++i)
+	{
+		if (dq[i + 10u] != i)
+		{
+			::fast_io::io::panicln("move_backward: shifted elements wrong at ", i);
+		}
+	}
+
+	::fast_io::io::print("deque std::move_backward test finished\n");
+}
+
+} // namespace
+
+int main()
+{
+	test_copy();
+	test_copy_backward();
+	test_move();
+	test_move_backward();
+}