请求：当共享指针被‘全引用捕获’时触发编译器警告

Great question—this is a super common pitfall when shifting from raw references to std::shared_ptr, and catching this risky pattern at compile time is way better than debugging mysterious segfaults later. Let’s walk through a few practical ways to make your compiler flag this issue:

1. Custom Wrapper Type with Compiler Warning (Clang/GCC) #

We can create a thin wrapper around std::shared_ptr that triggers a warning whenever someone takes a reference to it (which happens implicitly when you use [&] in a lambda). Here’s the code:

#include <memory>

template<typename T>
struct WarnSharedRefCapture : public std::shared_ptr<T> {
    // Inherit all constructors from std::shared_ptr
    using std::shared_ptr<T>::shared_ptr;

    // Overload address-of operator to emit a warning
    WarnSharedRefCapture<T>* operator&() 
        __attribute__((warn_unused_result, warning("⚠️ Capturing shared_ptr by reference is risky! Use value capture instead."))) {
        return this;
    }
};

// Replace std::shared_ptr with our wrapper in your function
void foo(WarnSharedRefCapture<const Bar> bar) {
    const auto fun = [&] () { some_other_api(bar); }; // Compiler will warn here!
    put_somewhere(fun);
}

When the lambda captures bar by reference, it implicitly takes the address of the variable, hitting our overloaded operator& which fires the custom warning. This is a targeted way to catch exactly the pattern you’re worried about.

2. Built-in Compiler Flags (No Code Changes) #

If you don’t want to modify your types, both GCC and Clang have flags that can catch this dangling reference risk:

• Clang: Use -Wdangling-reference—this warns when a lambda captures a local variable by reference that might outlive the lambda (like when you store the lambda via put_somewhere).
• GCC: Enable -Wdangling combined with -Wcatch-value=3—this flags cases where a reference capture could lead to a dangling pointer, especially when the lambda is stored or returned.

Just compile your code with these flags, and the compiler will flag the risky capture line in your foo function.

3. Static Analysis with Clang-Tidy #

For even deeper checking, use Clang-Tidy’s built-in static analysis checks. The clang-analyzer-core.DanglingReference check specifically detects when a lambda captures a local variable by reference and the lambda is stored beyond the scope of the function.

Run it with this command:

clang-tidy -checks='clang-analyzer-core.DanglingReference' your_source_file.cpp --

This will pinpoint the exact line where you’re capturing the shared_ptr by reference and flag it as a dangling reference risk.

Quick Recap of the Root Problem #

To make sure we’re on the same page: when you capture std::shared_ptr<const Bar> bar via [&], the lambda holds a reference to the local bar variable in foo. Once foo exits, bar is destroyed (its reference count drops to zero, deallocating the underlying Bar). If some_other_api is called later via the stored lambda, you’re accessing a destroyed shared_ptr—hence the segfault. The fix here is to capture by value ([=] or explicit [bar]) to increment the reference count, keeping the Bar instance alive as long as the lambda exists.

内容的提问来源于stack exchange，提问作者choeger