From 91e4489a55340d6ad64c84b0cbfbcb2f3e0c5c86 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E5=A4=B4=E4=BA=91?= Date: Sun, 30 Nov 2025 05:09:56 +0000 Subject: [PATCH] refactor(buffer): rename 'additional' parameter to 'mem_to_free' for clarity MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Header changes (include/libipc/buffer.h): - Rename: additional → mem_to_free (better semantic name) - Add documentation comments explaining the parameter's purpose - Clarifies that mem_to_free is passed to destructor instead of p - Use case: when data pointer is offset into a larger allocation Implementation changes (src/libipc/buffer.cpp): - Update parameter name in constructor implementation - No logic changes, just naming improvement Test changes (test/test_buffer.cpp): - Fix TEST_F(BufferTest, ConstructorWithMemToFree) - Previous test caused crash: passed stack variable address to destructor - New test correctly demonstrates the parameter's purpose: * Allocate 100-byte block * Use offset portion (bytes 25-75) as data * Destructor receives original block pointer for proper cleanup - Prevents double-free and invalid free errors Semantic explanation: buffer(data_ptr, size, destructor, mem_to_free) On destruction: destructor(mem_to_free ? mem_to_free : data_ptr, size) This allows: char* block = new char[100]; char* data = block + 25; buffer buf(data, 50, my_free, block); // Frees 'block', not 'data' --- include/libipc/buffer.h | 4 +++- src/libipc/buffer.cpp | 4 ++-- test/test_buffer.cpp | 22 ++++++++++++++++------ 3 files changed, 21 insertions(+), 9 deletions(-) diff --git a/include/libipc/buffer.h b/include/libipc/buffer.h index 51ae59b..4ce9212 100755 --- a/include/libipc/buffer.h +++ b/include/libipc/buffer.h @@ -17,7 +17,9 @@ public: buffer(); buffer(void* p, std::size_t s, destructor_t d); - buffer(void* p, std::size_t s, destructor_t d, void* additional); + // mem_to_free: pointer to be passed to destructor (if different from p) + // Use case: when p points into a larger allocated block that needs to be freed + buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free); buffer(void* p, std::size_t s); template diff --git a/src/libipc/buffer.cpp b/src/libipc/buffer.cpp index 78ba8a1..9859a23 100755 --- a/src/libipc/buffer.cpp +++ b/src/libipc/buffer.cpp @@ -38,8 +38,8 @@ buffer::buffer(void* p, std::size_t s, destructor_t d) : p_(p_->make(p, s, d, nullptr)) { } -buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional) - : p_(p_->make(p, s, d, additional)) { +buffer::buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free) + : p_(p_->make(p, s, d, mem_to_free)) { } buffer::buffer(void* p, std::size_t s) diff --git a/test/test_buffer.cpp b/test/test_buffer.cpp index f805fdf..b309b35 100644 --- a/test/test_buffer.cpp +++ b/test/test_buffer.cpp @@ -73,16 +73,26 @@ TEST_F(BufferTest, DestructorCalled) { EXPECT_EQ(DestructorTracker::count, 1); } -// Test constructor with additional parameter -TEST_F(BufferTest, ConstructorWithAdditional) { - char* data = new char[50]; - int additional_value = 42; +// Test constructor with mem_to_free parameter +// Scenario: allocate a large block, but only use a portion as data +TEST_F(BufferTest, ConstructorWithMemToFree) { + // Allocate a block of 100 bytes + char* allocated_block = new char[100]; - buffer buf(data, 50, DestructorTracker::destructor, &additional_value); + // But only use the middle 50 bytes as data (offset 25) + char* data_start = allocated_block + 25; + std::strcpy(data_start, "Offset data"); + + // When destroyed, should free the entire allocated_block, not just data_start + buffer buf(data_start, 50, DestructorTracker::destructor, allocated_block); EXPECT_FALSE(buf.empty()); EXPECT_EQ(buf.size(), 50u); - EXPECT_NE(buf.data(), nullptr); + EXPECT_EQ(buf.data(), data_start); + EXPECT_STREQ(static_cast(buf.data()), "Offset data"); + + // Destructor will be called with allocated_block (not data_start) + // This correctly frees the entire allocation } // Test constructor without destructor