C++智能指针避坑指南：90%人会犯的3个致命错误

码事漫谈2025-12-02 22:50

你以为将new替换为make_shared就万事大吉？真相是，智能指针的陷阱比手动管理更隐蔽、更危险。本文将深入剖析循环引用、性能陷阱、线程安全这三大「暗礁」，让你从「自以为会」到「真正精通」。

一个经典的崩溃代码

如下代码展露了智能指针中的循环引用问题。

cpp 复制代码 
// 这就是那个导致崩溃的简化版代码
class UserProfile {
    std::shared_ptr<UserProfile> recommend_to;  // 推荐给谁
    // ... 其他数据
};

void create_recommendation_cycle() {
    auto user1 = std::make_shared<UserProfile>();
    auto user2 = std::make_shared<UserProfile>();
    
    user1->recommend_to = user2;  // user1推荐user2
    user2->recommend_to = user1;  // user2又推荐user1
    
    // 离开作用域后，引用计数永远不会归零！
    // 内存泄漏，最终OOM（内存耗尽）
}

这就是智能指针最讽刺的地方：你为了避免内存泄漏而使用它，结果它却导致了更隐蔽的内存泄漏。

错误一：循环引用------智能指针的「鬼打墙」

1.1 循环引用的典型场景

cpp 复制代码 
// 场景1：双向关联（父子节点）
class TreeNode {
public:
    std::shared_ptr<TreeNode> parent;
    std::vector<std::shared_ptr<TreeNode>> children;
    
    void add_child(std::shared_ptr<TreeNode> child) {
        children.push_back(child);
        child->parent = shared_from_this();  // 致命错误！
    }
};

// 场景2：观察者模式中的相互持有
class Observer;
class Subject {
    std::vector<std::shared_ptr<Observer>> observers;
};

class Observer {
    std::shared_ptr<Subject> subject;  // 互相持有！
};

// 场景3：缓存系统中的自引用
class CacheEntry {
    std::shared_ptr<CacheEntry> next_in_lru;  // LRU链表
    std::shared_ptr<CacheEntry> prev_in_lru;
};

1.2 解决方案：weak_ptr的正确使用

cpp 复制代码 
// 正确方案1：使用weak_ptr打破循环
class TreeNode {
private:
    std::weak_ptr<TreeNode> parent_;  // 关键改变！
    std::vector<std::shared_ptr<TreeNode>> children_;
    
public:
    void set_parent(std::shared_ptr<TreeNode> parent) {
        parent_ = parent;  // weak_ptr不会增加引用计数
    }
    
    std::shared_ptr<TreeNode> get_parent() const {
        return parent_.lock();  // 尝试提升为shared_ptr
    }
    
    void add_child(std::shared_ptr<TreeNode> child) {
        children_.push_back(child);
        child->set_parent(shared_from_this());
    }
};

// 正确方案2：明确所有权关系
class Document {
    // 文档拥有页面（独占所有权）
    std::vector<std::unique_ptr<Page>> pages_;
    
    // 页面可以引用文档，但不拥有
    class Page {
        Document* document_;  // 原始指针！安全吗？
        // 这里的关键：生命周期由Document管理
    };
};

1.3 深度分析：weak_ptr的工作原理

cpp 复制代码 
// weak_ptr内部机制模拟
template<typename T>
class WeakPtr {
private:
    T* ptr_;                    // 指向实际对象
    ControlBlock* control_block_;  // 与shared_ptr共享的控制块
    
public:
    // lock()方法的实现
    std::shared_ptr<T> lock() const noexcept {
        if(control_block_ && control_block_->ref_count > 0) {
            // 对象还活着，创建新的shared_ptr
            return std::shared_ptr<T>(*this);
        }
        return std::shared_ptr<T>();  // 返回空shared_ptr
    }
    
    // 控制块结构
    struct ControlBlock {
        std::atomic<size_t> ref_count{1};     // 强引用计数
        std::atomic<size_t> weak_count{1};    // 弱引用计数
        T* object_ptr{nullptr};
        
        ~ControlBlock() {
            if(ref_count == 0) {
                delete object_ptr;  // 只有强引用为0时才删除对象
            }
            // weak_count为0时删除控制块本身
        }
    };
};

关键点：

  • weak_ptr不增加强引用计数 ，只增加弱引用计数
  • 对象销毁的条件：强引用计数 == 0
  • 控制块销毁的条件：强引用计数 == 0 且 弱引用计数 == 0

1.4 循环引用检测工具

cpp 复制代码 
// 运行时检测工具
class CyclicReferenceDetector {
public:
    template<typename T>
    static bool has_cycle(const std::shared_ptr<T>& start) {
        std::unordered_set<void*> visited;
        return detect_cycle(start, visited);
    }
    
private:
    template<typename T>
    static bool detect_cycle(const std::shared_ptr<T>& current,
                            std::unordered_set<void*>& visited) {
        if(!current) return false;
        
        void* address = current.get();
        if(visited.count(address)) {
            std::cerr << "Cycle detected at: " << typeid(T).name() 
                     << " [" << address << "]" << std::endl;
            return true;
        }
        
        visited.insert(address);
        
        // 使用反射或手动注册来遍历成员
        // 这里简化，实际需要更复杂的机制
        return false;
    }
};

// 使用示例
void check_for_cycles() {
    auto obj = std::make_shared<TreeNode>();
    // ... 构建可能循环的结构
    
    if(CyclicReferenceDetector::has_cycle(obj)) {
        std::cerr << "WARNING: Memory leak due to cyclic reference!" << std::endl;
    }
}

错误二：性能陷阱------你以为的「零成本」抽象

2.1 shared_ptr的隐藏成本

cpp 复制代码 
// 性能测试：shared_ptr vs 原始指针
void benchmark_shared_ptr() {
    constexpr size_t ITERATIONS = 1000000;
    std::vector<std::shared_ptr<Data>> shared_ptrs;
    std::vector<Data*> raw_ptrs;
    
    // 创建开销
    auto start = std::chrono::high_resolution_clock::now();
    for(size_t i = 0; i < ITERATIONS; ++i) {
        shared_ptrs.push_back(std::make_shared<Data>(i));
    }
    auto shared_create = std::chrono::high_resolution_clock::now() - start;
    
    start = std::chrono::high_resolution_clock::now();
    for(size_t i = 0; i < ITERATIONS; ++i) {
        raw_ptrs.push_back(new Data(i));
    }
    auto raw_create = std::chrono::high_resolution_clock::now() - start;
    
    std::cout << "创建开销:\n"
              << "  shared_ptr: " 
              << std::chrono::duration<double, std::milli>(shared_create).count()
              << "ms\n"
              << "  原始指针: "
              << std::chrono::duration<double, std::milli>(raw_create).count()
              << "ms\n";
    
    // 拷贝开销
    start = std::chrono::high_resolution_clock::now();
    for(size_t i = 0; i < ITERATIONS; ++i) {
        auto copy = shared_ptrs[i];  // 原子操作！
    }
    auto shared_copy = std::chrono::high_resolution_clock::now() - start;
    
    std::cout << "拷贝开销:\n"
              << "  shared_ptr: "
              << std::chrono::duration<double, std::milli>(shared_copy).count()
              << "ms (每个拷贝约"
              << std::chrono::duration<double, std::nano>(shared_copy).count()/ITERATIONS
              << "ns)\n";
}

性能开销来源：

  1. 控制块分配 ：额外的一次内存分配（除非用make_shared）
  2. 原子操作：引用计数的增减需要原子操作，影响多核性能
  3. 缓存不友好：对象和控制块可能不在同一缓存行
  4. 虚函数开销：自定义删除器和分配器可能引入间接调用

2.2 make_shared vs shared_ptr构造函数

cpp 复制代码 
// 关键区别：内存布局
class LargeObject {
    char data[1024];  // 1KB数据
};

void memory_layout_demo() {
    // 方式1：两次内存分配
    std::shared_ptr<LargeObject> p1(new LargeObject);
    // 堆布局：[控制块] ... [LargeObject]
    // 两次分配，可能内存碎片
    
    // 方式2：一次内存分配（推荐）
    auto p2 = std::make_shared<LargeObject>();
    // 堆布局：[控制块 + LargeObject]
    // 单次分配，更好的局部性
    
    // 但注意：weak_ptr会阻止整个内存块释放
    std::weak_ptr<LargeObject> weak = p2;
    p2.reset();  // LargeObject析构，但内存直到weak销毁才释放
}

2.3 性能优化策略

cpp 复制代码 
// 策略1：优先使用unique_ptr
class ConnectionPool {
private:
    // 池拥有所有连接
    std::vector<std::unique_ptr<Connection>> connections_;
    
    // 借出时返回原始指针或引用
    Connection* borrow_connection() {
        return connections_[next_available_].get();
    }
    
    // unique_ptr没有引用计数开销
    // 所有权清晰，零额外成本
};

// 策略2：传递const引用而不是拷贝shared_ptr
void process_data_bad(const std::shared_ptr<Data>& data) {
    // 这里看似没有拷贝，但可能在其他地方有
    auto local_copy = data;  // 原子递增！
    // ...
}

void process_data_good(const Data& data) {  // 直接传递引用
    // 没有引用计数操作
    // 调用者需保证data的生命周期
}

// 策略3：局部使用shared_ptr，长期使用weak_ptr
class SessionManager {
private:
    std::unordered_map<SessionId, std::weak_ptr<Session>> sessions_;
    
public:
    std::shared_ptr<Session> get_session(SessionId id) {
        if(auto it = sessions_.find(id); it != sessions_.end()) {
            if(auto session = it->second.lock()) {
                return session;  // 会话还活着
            }
            sessions_.erase(it);  // 会话已过期，清理
        }
        return nullptr;
    }
    
    void register_session(SessionId id, std::shared_ptr<Session> session) {
        sessions_[id] = session;  // 存储weak_ptr，不阻止销毁
    }
};

2.4 原子操作的性能影响

cpp 复制代码 
// shared_ptr引用计数的原子操作（简化版）
template<typename T>
class SharedPtr {
    T* ptr;
    std::atomic<long>* ref_count;  // 原子类型
    
public:
    SharedPtr(const SharedPtr& other) : ptr(other.ptr), ref_count(other.ref_count) {
        // 内存屏障！影响多核性能
        ref_count->fetch_add(1, std::memory_order_relaxed);
    }
    
    ~SharedPtr() {
        if(ref_count->fetch_sub(1, std::memory_order_acq_rel) == 1) {
            delete ptr;
            delete ref_count;
        }
    }
};

// 性能对比：单线程 vs 多线程
void atomic_overhead_demo() {
    std::atomic<int> atomic_counter{0};
    int non_atomic_counter = 0;
    
    constexpr int ITERATIONS = 10000000;
    
    // 单线程性能
    auto start = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < ITERATIONS; ++i) {
        atomic_counter.fetch_add(1, std::memory_order_relaxed);
    }
    auto atomic_time = std::chrono::high_resolution_clock::now() - start;
    
    start = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < ITERATIONS; ++i) {
        ++non_atomic_counter;
    }
    auto non_atomic_time = std::chrono::high_resolution_clock::now() - start;
    
    std::cout << "原子操作开销: "
              << std::chrono::duration<double, std::milli>(atomic_time).count() / 
                 std::chrono::duration<double, std::milli>(non_atomic_time).count()
              << "倍\n";
}

错误三：线程安全------最危险的幻觉

3.1 shared_ptr的线程安全层级

cpp 复制代码 
// shared_ptr的线程安全是分层的：
class ThreadSafetyLevels {
    // 级别1：控制块线程安全（标准保证）
    //   - 引用计数的增减是原子的
    //   - 不同的shared_ptr实例可以被不同线程安全地析构
    
    // 级别2：指向的数据线程不安全！
    //   - shared_ptr不保证其管理的对象的线程安全
    //   - 多个线程同时读写同一个对象需要外部同步
    
    // 级别3：同一个shared_ptr实例的读写不安全！
    //   - 同一个shared_ptr对象被多个线程读写需要同步
};

// 证明：shared_ptr内部不保护对象
void concurrent_access_problem() {
    auto shared_data = std::make_shared<std::vector<int>>();
    
    // 线程1：修改数据
    std::thread t1([&shared_data]() {
        for(int i = 0; i < 1000; ++i) {
            shared_data->push_back(i);  // 竞态条件！
        }
    });
    
    // 线程2：同时读取
    std::thread t2([&shared_data]() {
        for(int i = 0; i < 1000; ++i) {
            if(!shared_data->empty()) {
                int value = shared_data->back();  // 可能读取到无效数据！
            }
        }
    });
    
    t1.join();
    t2.join();
    // 结果：未定义行为！可能崩溃或数据损坏
}

3.2 典型线程安全问题

cpp 复制代码 
// 问题1：错误的「线程安全」假设
class ThreadUnsafeCache {
    std::unordered_map<std::string, std::shared_ptr<Data>> cache_;
    std::mutex mutex_;
    
public:
    std::shared_ptr<Data> get(const std::string& key) {
        std::lock_guard<std::mutex> lock(mutex_);
        if(auto it = cache_.find(key); it != cache_.end()) {
            return it->second;  // 看似安全...
        }
        return nullptr;
    }
    
    // 问题：返回的shared_ptr可能被多个线程同时持有
    // 它们可以同时修改Data，而Data没有内置的线程保护！
};

// 问题2：shared_ptr的原子操作误解
void atomic_shared_ptr_misconception() {
    std::shared_ptr<int> p = std::make_shared<int>(42);
    
    std::thread t1([&p]() {
        auto local_copy = p;  // 引用计数原子递增
        // 但p.reset()可能同时发生！
    });
    
    std::thread t2([&p]() {
        p.reset(new int(100));  // 修改p本身需要同步！
    });
    
    t1.join();
    t2.join();
    // 这里有两个独立的数据竞争：
    // 1. 对p本身的修改（shared_ptr对象）
    // 2. 对新旧int对象的访问
};

3.3 线程安全智能指针实现

cpp 复制代码 
// 方案1：使用atomic_shared_ptr（C++20）
#include <atomic>
#include <memory>

void cpp20_atomic_shared_ptr() {
    std::atomic<std::shared_ptr<int>> atomic_ptr;
    
    // 线程安全地存储
    std::thread writer([&atomic_ptr]() {
        atomic_ptr.store(std::make_shared<int>(42));
    });
    
    // 线程安全地加载
    std::thread reader([&atomic_ptr]() {
        std::shared_ptr<int> local = atomic_ptr.load();
        if(local) {
            // 安全读取local指向的内容
            // 但多个reader可能同时读取，内容本身需要保护
        }
    });
    
    writer.join();
    reader.join();
}

// 方案2：手动实现带锁的智能指针
template<typename T>
class ThreadSafeSharedPtr {
private:
    struct ControlBlock {
        T* ptr;
        std::atomic<size_t> ref_count;
        std::mutex data_mutex;  // 保护对象本身
        
        // 自定义删除器，确保安全销毁
        void safe_delete() {
            std::lock_guard<std::mutex> lock(data_mutex);
            delete ptr;
            ptr = nullptr;
        }
    };
    
    ControlBlock* cb_;
    
public:
    // 提供线程安全的访问接口
    template<typename Func>
    auto with_lock(Func&& func) {
        std::lock_guard<std::mutex> lock(cb_->data_mutex);
        return std::forward<Func>(func)(*cb_->ptr);
    }
    
    // 线程安全的reset
    void reset(T* new_ptr = nullptr) {
        if(cb_ && cb_->ref_count.fetch_sub(1) == 1) {
            cb_->safe_delete();
            delete cb_;
        }
        if(new_ptr) {
            cb_ = new ControlBlock{new_ptr, 1};
        } else {
            cb_ = nullptr;
        }
    }
};

3.4 多线程环境最佳实践

cpp 复制代码 
// 最佳实践1：使用不可变数据
class ImmutableData {
private:
    const std::vector<int> data_;  // 构造后不可变
    
public:
    // 线程安全：多个线程可以同时读取
    int get(size_t index) const {
        return data_.at(index);
    }
    
    // 创建新版本而不是修改
    std::shared_ptr<ImmutableData> with_addition(int value) const {
        auto new_data = std::make_shared<ImmutableData>(*this);
        // 注意：这里需要实际的不可变实现
        return new_data;
    }
};

// 最佳实践2：明确的所有权传递
class ThreadSafeMessageQueue {
private:
    struct Message {
        std::unique_ptr<Data> data;  // 独占所有权
        // unique_ptr明确表示：只有一个线程拥有
    };
    
    std::queue<Message> queue_;
    std::mutex queue_mutex_;
    std::condition_variable cv_;
    
public:
    // 生产者：转移所有权到队列
    void push(std::unique_ptr<Data> data) {
        {
            std::lock_guard<std::mutex> lock(queue_mutex_);
            queue_.push(Message{std::move(data)});
        }
        cv_.notify_one();
    }
    
    // 消费者：从队列获取所有权
    std::unique_ptr<Data> pop() {
        std::unique_lock<std::mutex> lock(queue_mutex_);
        cv_.wait(lock, [this]{ return !queue_.empty(); });
        
        Message msg = std::move(queue_.front());
        queue_.pop();
        
        return std::move(msg.data);  // 所有权转移给消费者
    }
};

// 最佳实践3：使用shared_ptr的别名构造函数
class ThreadSafeObserver {
private:
    std::shared_ptr<std::mutex> mutex_;  // 共享的mutex
    std::shared_ptr<Data> data_;          // 共享的数据
    
public:
    ThreadSafeObserver(std::shared_ptr<Data> data)
        : data_(data)
        , mutex_(std::make_shared<std::mutex>()) {}
    
    void process() {
        std::lock_guard<std::mutex> lock(*mutex_);
        // 安全地访问data_
        // data_和mutex_的生命周期绑定在一起
    }
    
    // 创建观察者副本
    ThreadSafeObserver clone() const {
        return ThreadSafeObserver(data_);  // 共享相同的mutex和数据
    }
};

综合案例：一个线程安全、高性能的对象池

cpp 复制代码 
// 完整的最佳实践示例
template<typename T>
class ThreadSafeObjectPool {
private:
    struct PooledObject {
        T object;
        bool in_use{false};
        std::chrono::steady_clock::time_point last_used;
    };
    
    // 使用unique_ptr管理池中对象
    std::vector<std::unique_ptr<PooledObject>> pool_;
    
    // 可用的对象使用weak_ptr引用
    std::vector<std::weak_ptr<T>> available_;
    
    // 线程安全
    mutable std::shared_mutex mutex_;
    
    // 避免循环引用的关键：自定义删除器
    struct PoolDeleter {
        ThreadSafeObjectPool* pool;
        
        void operator()(T* ptr) {
            // 不是真的删除，而是返回池中
            pool->return_to_pool(ptr);
        }
    };
    
public:
    // 获取对象：返回带自定义删除器的shared_ptr
    std::shared_ptr<T> acquire() {
        std::unique_lock lock(mutex_);
        
        // 清理过期的weak_ptr
        available_.erase(
            std::remove_if(available_.begin(), available_.end(),
                [](const std::weak_ptr<T>& wp) { return wp.expired(); }),
            available_.end()
        );
        
        // 尝试从可用对象中获取
        for(auto it = available_.begin(); it != available_.end(); ++it) {
            if(auto sp = it->lock()) {
                // 找到可用对象
                available_.erase(it);
                
                // 查找对应的PooledObject并标记为使用中
                for(auto& pooled_obj : pool_) {
                    if(&pooled_obj->object == sp.get()) {
                        pooled_obj->in_use = true;
                        pooled_obj->last_used = std::chrono::steady_clock::now();
                        break;
                    }
                }
                
                return sp;
            }
        }
        
        // 创建新对象
        auto pooled_obj = std::make_unique<PooledObject>();
        T* raw_ptr = &pooled_obj->object;
        pooled_obj->in_use = true;
        pooled_obj->last_used = std::chrono::steady_clock::now();
        
        // 创建带自定义删除器的shared_ptr
        std::shared_ptr<T> sp(raw_ptr, PoolDeleter{this});
        
        // 存储unique_ptr以管理生命周期
        pool_.push_back(std::move(pooled_obj));
        
        return sp;
    }
    
private:
    // 对象返回到池中（由自定义删除器调用）
    void return_to_pool(T* ptr) {
        std::unique_lock lock(mutex_);
        
        // 查找对应的PooledObject
        for(auto& pooled_obj : pool_) {
            if(&pooled_obj->object == ptr) {
                pooled_obj->in_use = false;
                
                // 创建新的weak_ptr添加到可用列表
                available_.push_back(
                    std::shared_ptr<T>(std::shared_ptr<T>{}, ptr)  // 别名构造函数
                );
                break;
            }
        }
    }
    
    // 清理长时间未用的对象
    void cleanup_old_objects(std::chrono::seconds max_idle_time) {
        std::unique_lock lock(mutex_);
        
        auto now = std::chrono::steady_clock::now();
        
        for(auto it = pool_.begin(); it != pool_.end(); ) {
            auto& pooled_obj = *it;
            
            if(!pooled_obj->in_use && 
               (now - pooled_obj->last_used) > max_idle_time) {
                // 从available_中移除对应的weak_ptr
                available_.erase(
                    std::remove_if(available_.begin(), available_.end(),
                        [obj_ptr = &pooled_obj->object](const std::weak_ptr<T>& wp) {
                            if(auto sp = wp.lock()) {
                                return sp.get() == obj_ptr;
                            }
                            return false;
                        }),
                    available_.end()
                );
                
                // 删除对象
                it = pool_.erase(it);
            } else {
                ++it;
            }
        }
    }
};

// 使用示例
void use_object_pool() {
    ThreadSafeObjectPool<DatabaseConnection> pool;
    
    // 多线程安全地获取连接
    std::vector<std::thread> threads;
    for(int i = 0; i < 10; ++i) {
        threads.emplace_back([&pool, i]() {
            // 获取连接（可能阻塞直到有可用连接）
            auto conn = pool.acquire();
            
            // 使用连接
            conn->execute_query("SELECT * FROM users");
            
            // conn离开作用域，自动返回到池中
            // 因为使用了自定义删除器
        });
    }
    
    for(auto& t : threads) {
        t.join();
    }
}

智能指针的三大「生存法则」

法则一：所有权设计优先

  1. 能使用unique_ptr就不要用shared_ptr
  2. 明确对象的所有权生命周期
  3. 使用weak_ptr打破循环引用

法则二：性能意识常驻

  1. 优先使用make_shared/make_unique
  2. 避免不必要的shared_ptr拷贝
  3. 注意原子操作的开销

法则三：线程安全不假设

  1. shared_ptr的线程安全仅限于控制块
  2. 指向的数据需要额外保护
  3. 考虑使用不可变数据结构

最终检查清单

cpp 复制代码 
// 每次使用智能指针前问自己：
1. 这个对象应该被谁拥有？□ unique_ptr □ shared_ptr
2. 是否有循环引用的可能？□ 有（需weak_ptr） □ 无
3. 是否会在多线程中使用？□ 是（需同步） □ 否
4. 是否需要最优性能？□ 是（避免shared_ptr） □ 否
5. 是否传递所有权？□ 是（移动语义） □ 否（传递引用）

从「会用」到「精通」

智能指针不是「银弹」，而是「双刃剑」。它解决了手动管理内存的烦恼，却引入了更隐蔽的陷阱。真正的精通，不是记住语法，而是理解每个设计决策背后的权衡。

正如C++之父Bjarne Stroustrup所说：「C++的设计初衷是让好的设计更容易，坏的设计更困难」。智能指针正是这一哲学的体现------它奖励清晰的所有权设计，惩罚模糊的资源管理。

下次当你写下std::shared_ptr时，不妨停顿一秒，问问自己：「我真的需要共享所有权吗？」这个简单的问题，可能就是避免下一个深夜崩溃的关键。

深度阅读推荐：

  1. 《Effective Modern C++》条款18-22：智能指针专题
  2. 《C++ Concurrency in Action》第7章：无锁数据结构中的智能指针
  3. Boost.smart_ptr 源码分析
  4. Facebook folly库中的智能指针扩展
相关推荐
码事漫谈1 小时前
不止于代码：一位开发者在2025开放原子大会的见闻与破圈思考
后端
计算机毕设小月哥1 小时前
【Hadoop+Spark+python毕设】中国租房信息可视化分析系统、计算机毕业设计、包括数据爬取、Spark、数据分析、数据可视化、Hadoop
后端·python·mysql
x***38161 小时前
Spring Boot项目中解决跨域问题（四种方式）
spring boot·后端·dubbo
Coder-coco2 小时前
在线商城系统|基于springboot vue在线商城系统(源码+数据库+文档)
java·数据库·vue.js·spring boot·后端·宠物
7***68432 小时前
Spring Boot 热部署
java·spring boot·后端
k***45992 小时前
Spring Boot实时推送技术详解：三个经典案例
spring boot·后端·状态模式
n***63272 小时前
DeepSeek API 调用 - Spring Boot 实现
windows·spring boot·后端
Croa-vo3 小时前
Tesla Spring 2026 Co-op 面经：CodeSignal真题解析与通关攻略
java·后端·spring
华仔啊3 小时前
SpringBoot 动态菜单权限系统设计的企业级解决方案
java·后端
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06本地部署阿里最新开源的Z-Image07Meta第三代“分割一切”模型——SAM 3本地部署教程：首支持文本提示分割，400万概念、30毫秒响应，检测分割追踪一网打尽0846个Nano-banana 精选提示词，持续更新中09【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连10Gemini 3.0 Pro Preview 实测报告