diff --git a/src/backend/src/misc/src/audio_ring_buffer.h b/src/backend/src/misc/src/audio_ring_buffer.h
index 1a1e264..86cbe4a 100644
--- a/src/backend/src/misc/src/audio_ring_buffer.h
+++ b/src/backend/src/misc/src/audio_ring_buffer.h
@@ -44,10 +44,10 @@ private:
 		std::atomic<size_t> processed_read_pos{ 0 };
 		std::atomic<size_t> audio_write_pos{ 0 };
 		std::atomic<size_t> audio_read_pos{ 0 };
-		size_t              queue_capacity;
-		size_t              audio_buffer_size;
-		size_t              block_size;
-		char                initialized; // 初始化标志
+		size_t              queue_capacity{};
+		size_t              audio_buffer_size{};
+		size_t              block_size{};
+		char                initialized{}; // 初始化标志
 
 		shared_control_block() = default;
 
@@ -77,10 +77,9 @@ private:
 
 	// 共享内存中的数据结构
 	shared_control_block* control_;
-	queue_entry*         pending_queue_;
-	queue_entry*         processed_queue_;
-	T*                  audio_buffer_;
-
+	queue_entry*          pending_queue_;
+	queue_entry*          processed_queue_;
+	T*                    audio_buffer_;
 public:
 	// 构造函数1：创建新的共享内存段
 	audio_ring_buffer(const char* segment_name,
@@ -100,7 +99,7 @@ public:
 	}
 
 	// 构造函数2：连接到现有共享内存段
-	audio_ring_buffer(const char* segment_name) : segment_(nullptr),
+	explicit audio_ring_buffer(const char* segment_name) : segment_(nullptr),
 												  owns_segment_(true) {
 		segment_ = new bip::managed_shared_memory(bip::open_only, segment_name);
 
@@ -116,7 +115,7 @@ public:
 	}
 
 	// 构造函数4：连接到外部managed_shared_memory中的现有结构
-	audio_ring_buffer(bip::managed_shared_memory& external_segment) : segment_(&external_segment),
+	explicit audio_ring_buffer(bip::managed_shared_memory& external_segment) : segment_(&external_segment),
 																	  owns_segment_(false) {
 		connect_to_existing_structures();
 	}
@@ -157,11 +156,11 @@ public:
 	audio_ring_buffer& operator=(const audio_ring_buffer&) = delete;
 
 	// 获取可用的音频块用于写入
-	audio_block acquire_pending_block(size_t required_size) {
-		size_t write_pos = control_->audio_write_pos.load(std::memory_order_acquire);
-		size_t read_pos  = control_->audio_read_pos.load(std::memory_order_acquire);
+	auto acquire_pending_block(size_t required_size) {
+		auto write_pos = control_->audio_write_pos.load(std::memory_order_acquire);
+		auto read_pos  = control_->audio_read_pos.load(std::memory_order_acquire);
 
-		size_t available = calculate_available_space(write_pos, read_pos);
+		auto available = calculate_available_space(write_pos, read_pos);
 		if (available < required_size) { return audio_block(); }
 
 		// 处理环绕
@@ -176,26 +175,26 @@ public:
 		return audio_block(audio_buffer_ + write_pos, required_size);
 	}
 
-	bool commit_pending_block(const audio_block& block, uint64_t timestamp = 0) {
-		size_t queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
-		size_t queue_read  = control_->pending_read_pos.load(std::memory_order_acquire);
+	auto commit_pending_block(const audio_block& block, uint64_t timestamp = 0) {
+		auto queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
+		auto queue_read  = control_->pending_read_pos.load(std::memory_order_acquire);
 
 		if (is_queue_full(queue_write, queue_read)) { return false; }
 
-		size_t audio_offset         = block.data - audio_buffer_;
+		auto audio_offset         = block.data - audio_buffer_;
 		pending_queue_[queue_write] = queue_entry(audio_offset, block.size, timestamp);
 
 		control_->audio_write_pos.store(audio_offset + block.size, std::memory_order_release);
 
-		size_t next_write = (queue_write + 1) % control_->queue_capacity;
+		auto next_write = (queue_write + 1) % control_->queue_capacity;
 		control_->pending_write_pos.store(next_write, std::memory_order_release);
 
 		return true;
 	}
 
-	audio_block get_pending_block() {
-		size_t queue_read  = control_->pending_read_pos.load(std::memory_order_acquire);
-		size_t queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
+	auto get_pending_block() {
+		auto queue_read  = control_->pending_read_pos.load(std::memory_order_acquire);
+		auto queue_write = control_->pending_write_pos.load(std::memory_order_acquire);
 
 		if (queue_read == queue_write) { return audio_block(); }
 
@@ -203,21 +202,21 @@ public:
 		return audio_block(audio_buffer_ + entry.audio_offset, entry.size, entry.timestamp);
 	}
 
-	bool complete_pending_block() {
-		size_t pending_read  = control_->pending_read_pos.load(std::memory_order_acquire);
-		size_t pending_write = control_->pending_write_pos.load(std::memory_order_acquire);
+	auto complete_pending_block() {
+		auto pending_read  = control_->pending_read_pos.load(std::memory_order_acquire);
+		auto pending_write = control_->pending_write_pos.load(std::memory_order_acquire);
 
 		if (pending_read == pending_write) { return false; }
 
-		size_t processed_write = control_->processed_write_pos.load(std::memory_order_acquire);
-		size_t processed_read  = control_->processed_read_pos.load(std::memory_order_acquire);
+		auto processed_write = control_->processed_write_pos.load(std::memory_order_acquire);
+		auto processed_read  = control_->processed_read_pos.load(std::memory_order_acquire);
 
 		if (is_queue_full(processed_write, processed_read)) { return false; }
 
 		processed_queue_[processed_write] = pending_queue_[pending_read];
 
-		size_t next_pending_read    = (pending_read + 1) % control_->queue_capacity;
-		size_t next_processed_write = (processed_write + 1) % control_->queue_capacity;
+		auto next_pending_read    = (pending_read + 1) % control_->queue_capacity;
+		auto next_processed_write = (processed_write + 1) % control_->queue_capacity;
 
 		control_->pending_read_pos.store(next_pending_read, std::memory_order_release);
 		control_->processed_write_pos.store(next_processed_write, std::memory_order_release);
@@ -225,9 +224,9 @@ public:
 		return true;
 	}
 
-	audio_block get_processed_block() {
-		size_t queue_read  = control_->processed_read_pos.load(std::memory_order_acquire);
-		size_t queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
+	auto get_processed_block() {
+		auto queue_read  = control_->processed_read_pos.load(std::memory_order_acquire);
+		auto queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
 
 		if (queue_read == queue_write) { return audio_block(); }
 
@@ -235,39 +234,39 @@ public:
 		return audio_block(audio_buffer_ + entry.audio_offset, entry.size, entry.timestamp);
 	}
 
-	bool release_processed_block() {
-		size_t queue_read  = control_->processed_read_pos.load(std::memory_order_acquire);
-		size_t queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
+	auto release_processed_block() {
+		auto queue_read  = control_->processed_read_pos.load(std::memory_order_acquire);
+		auto queue_write = control_->processed_write_pos.load(std::memory_order_acquire);
 
 		if (queue_read == queue_write) { return false; }
 
 		const queue_entry& entry = processed_queue_[queue_read];
 
-		size_t expected_read_pos = entry.audio_offset + entry.size;
+		auto expected_read_pos = entry.audio_offset + entry.size;
 		control_->audio_read_pos.store(expected_read_pos, std::memory_order_release);
 
-		size_t next_read = (queue_read + 1) % control_->queue_capacity;
+		auto next_read = (queue_read + 1) % control_->queue_capacity;
 		control_->processed_read_pos.store(next_read, std::memory_order_release);
 
 		return true;
 	}
 
 	// 状态查询方法
-	size_t pending_count() const {
-		size_t write = control_->pending_write_pos.load(std::memory_order_acquire);
-		size_t read  = control_->pending_read_pos.load(std::memory_order_acquire);
+	[[nodiscard]] auto pending_count() const {
+		auto write = control_->pending_write_pos.load(std::memory_order_acquire);
+		auto read  = control_->pending_read_pos.load(std::memory_order_acquire);
 		return (write >= read) ? (write - read) : (control_->queue_capacity - read + write);
 	}
 
-	size_t processed_count() const {
-		size_t write = control_->processed_write_pos.load(std::memory_order_acquire);
-		size_t read  = control_->processed_read_pos.load(std::memory_order_acquire);
+	[[nodiscard]] auto processed_count() const {
+		auto write = control_->processed_write_pos.load(std::memory_order_acquire);
+		auto read  = control_->processed_read_pos.load(std::memory_order_acquire);
 		return (write >= read) ? (write - read) : (control_->queue_capacity - read + write);
 	}
 
-	size_t available_audio_space() const {
-		size_t write = control_->audio_write_pos.load(std::memory_order_acquire);
-		size_t read  = control_->audio_read_pos.load(std::memory_order_acquire);
+	[[nodiscard]] auto available_audio_space() const {
+		auto write = control_->audio_write_pos.load(std::memory_order_acquire);
+		auto read  = control_->audio_read_pos.load(std::memory_order_acquire);
 		return calculate_available_space(write, read);
 	}
 
@@ -281,13 +280,12 @@ public:
 	}
 
 	// Boost特有的功能
-	bip::managed_shared_memory&       get_segment() { return *segment_; }
-	const bip::managed_shared_memory& get_segment() const { return *segment_; }
+	[[nodiscard]] auto&       get_segment() { return *segment_; }
+	[[nodiscard]] const auto& get_segment() const { return *segment_; }
 
 	// 获取共享内存使用统计
-	size_t get_free_memory() const { return segment_->get_free_memory(); }
-	size_t get_size() const { return segment_->get_size(); }
-
+	[[nodiscard]] auto get_free_memory() const { return segment_->get_free_memory(); }
+	[[nodiscard]] auto get_size() const { return segment_->get_size(); }
 private:
 	void initialize_shared_structures(size_t queue_capacity, size_t audio_buffer_capacity) {
 		// 在共享内存中构造控制块
@@ -330,12 +328,12 @@ private:
 		audio_buffer_ = audio_result.first;
 	}
 
-	size_t calculate_available_space(size_t write_pos, size_t read_pos) const {
+	[[nodiscard]] auto calculate_available_space(size_t write_pos, size_t read_pos) const {
 		if (write_pos >= read_pos) { return control_->audio_buffer_size - write_pos + read_pos - 1; }
-		else { return read_pos - write_pos - 1; }
+		return read_pos - write_pos - 1;
 	}
 
-	bool is_queue_full(size_t write_pos, size_t read_pos) const {
+	[[nodiscard]] auto is_queue_full(size_t write_pos, size_t read_pos) const {
 		return ((write_pos + 1) % control_->queue_capacity) == read_pos;
 	}
 };