C++ ADL(参数依赖查找)问题及解决方案

无价之保 發表於 2025-12-25 16:19:59

C++ ADL(参数依赖查找)问题及解决方案

<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>C++ ADL（参数依赖查找）问题详解</li><ul class="second_class_ul"><li>1. ADL基础概念</li><ul class="third_class_ul"><li>1.1 什么是ADL？</li></ul><li>2. ADL的工作原理</li><ul class="third_class_ul"><li>2.1 查找规则</li><li>2.2 关联命名空间和类</li></ul><li>3. ADL引发的问题</li><ul class="third_class_ul"><li>3.1 意外的函数调用</li><li>3.2 std::swap的ADL陷阱</li><li>3.3 运算符重载的ADL问题</li><li>3.4 隐藏的依赖问题</li></ul><li>4. 解决方案</li><ul class="third_class_ul"><li>4.1 使用完全限定名</li><li>4.2 使用括号禁用ADL</li><li>4.3 使用函数指针强制类型</li><li>4.4 通用swap模式</li><li>4.5 类型别名和ADL</li></ul><li>5. ADL的高级技巧</li><ul class="third_class_ul"><li>5.1 利用ADL实现定制点</li><li>5.2 ADL与CRTP模式</li><li>5.3 ADL防护（SFINAE + ADL）</li></ul><li>6. 标准库中的ADL应用</li><ul class="third_class_ul"><li>6.1 std::begin和std::end</li><li>6.2 std::hash特化的ADL</li></ul><li>7. 调试和诊断ADL问题</li><ul class="third_class_ul"><li>7.1 使用编译器诊断</li><li>7.2 静态分析工具</li></ul><li>8. 最佳实践总结</li><ul class="third_class_ul"><li>8.1 DOs and DON’Ts</li><li>8.2 设计指南</li><li>8.3 团队规范</li></ul><li>9. 完整示例：安全的ADL使用框架</li><ul class="third_class_ul"></ul><li>10. 总结</li><ul class="third_class_ul"></ul></ul></ul></div><p class="maodian"></p><h2>C++ ADL（参数依赖查找）问题详解</h2>
<p class="maodian"></p><h3>1. ADL基础概念</h3>
<p class="maodian"></p><h4>1.1 什么是ADL？</h4>
<p>ADL（Argument-Dependent Lookup，又称Koenig查找）是C++的一个特性，它允许在函数调用时，除了在通常的作用域中查找函数名，还会在函数参数类型所属的命名空间中查找。</p>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
namespace Math {
class Complex {
   double real, imag;
public:
   Complex(double r, double i) : real(r), imag(i) {}
   // 重载加法运算符
   Complex operator+(const Complex& other) const {
         return Complex(real + other.real, imag + other.imag);
   }
};
// 全局加法函数
Complex add(const Complex& a, const Complex& b) {
   return a + b;
}
void print(const Complex& c) {
   std::cout << "Complex number" << std::endl;
}
}
int main() {
Math::Complex c1(1.0, 2.0);
Math::Complex c2(3.0, 4.0);
// ADL在起作用：print在Math命名空间中
print(c1);// 正确：ADL找到了Math::print
// 没有ADL的情况
// Math::print(c1);// 需要显式指定命名空间
return 0;
}</pre></div>
<p class="maodian"></p><h3>2. ADL的工作原理</h3>
<p class="maodian"></p><h4>2.1 查找规则</h4>
<div class="jb51code"><pre class="brush:cpp;">namespace A {
class X {};
void func(X) { std::cout << "A::func" << std::endl; }
}
namespace B {
void func(int) { std::cout << "B::func" << std::endl; }
void test() {
   A::X x;
   func(x);// ADL：在A中查找func，调用A::func
   func(42); // 在B中查找func，调用B::func
}
}
int main() {
B::test();
return 0;
}</pre></div>
<p class="maodian"></p><h4>2.2 关联命名空间和类</h4>
<div class="jb51code"><pre class="brush:cpp;">namespace Outer {
class Inner {
public:
   class Nested {};
};
void process(Inner) {}
void process(Inner::Nested) {}
}
int main() {
Outer::Inner inner;
Outer::Inner::Nested nested;
process(inner); // ADL找到Outer::process
process(nested); // ADL找到Outer::process
return 0;
}</pre></div>
<p class="maodian"></p><h3>3. ADL引发的问题</h3>
<p class="maodian"></p><h4>3.1 意外的函数调用</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
namespace LibraryA {
class Data {
public:
   Data(int v) : value(v) {}
   int value;
};
void process(const Data& d) {
   std::cout << "LibraryA::process: " << d.value << std::endl;
}
}
namespace LibraryB {
void process(int x) {
   std::cout << "LibraryB::process: " << x << std::endl;
}
void doWork() {
   LibraryA::Data data(42);
   // 意图：调用LibraryB::process(int)
   // 实际：ADL找到LibraryA::process(const Data&)
   process(data);// 意外调用LibraryA::process!
   // 正确方式
   process(100); // 调用LibraryB::process
   LibraryA::process(data);// 明确指定
}
}
int main() {
LibraryB::doWork();
return 0;
}</pre></div>
<p class="maodian"></p><h4>3.2 std::swap的ADL陷阱</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <utility>
#include <vector>
namespace MyLib {
class Widget {
public:
   Widget(int v) : value(v) {}
   int value;
};
// 自定义swap
void swap(Widget& a, Widget& b) {
   std::cout << "MyLib::swap called" << std::endl;
   std::swap(a.value, b.value);
}
}
// 通用模板函数
template<typename T>
void mySwap(T& a, T& b) {
using std::swap;// 关键：将std::swap引入当前作用域
swap(a, b);    // ADL会查找最适合的swap
}
int main() {
MyLib::Widget w1(10), w2(20);
// 错误方式：可能不会调用自定义swap
std::swap(w1, w2);// 总是调用std::swap
// 正确方式：使用ADL友好的swap
using std::swap;
swap(w1, w2);// 调用MyLib::swap（ADL）
// 在模板中的正确方式
mySwap(w1, w2);// 调用MyLib::swap
return 0;
}</pre></div>
<p class="maodian"></p><h4>3.3 运算符重载的ADL问题</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
namespace Lib1 {
class Matrix {
public:
   Matrix(int v) : value(v) {}
   int value;
};
// 重载+
Matrix operator+(const Matrix& a, const Matrix& b) {
   return Matrix(a.value + b.value);
}
}
namespace Lib2 {
class Vector {
public:
   Vector(int v) : value(v) {}
   int value;
};
// 也重载+，但类型不同
Vector operator+(const Vector& a, const Vector& b) {
   return Vector(a.value + b.value);
}
void calculate() {
   Lib1::Matrix m1(10), m2(20);
   // 意外：ADL找到Lib1::operator+
   auto result = m1 + m2;// 调用Lib1::operator+
   // 如果Lib2也定义了Matrix类，会发生什么？
}
}
// 更复杂的情况：模板和ADL
template<typename T>
class Container {
T value;
public:
Container(T v) : value(v) {}
// 尝试定义加法
Container operator+(const Container& other) const {
   // 这里会发生ADL查找T的operator+
   return Container(value + other.value);
}
};
int main() {
Lib2::calculate();
return 0;
}</pre></div>
<p class="maodian"></p><h4>3.4 隐藏的依赖问题</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <iterator>
#include <algorithm>
namespace Hidden {
class Data {
   int value;
public:
   Data(int v) : value(v) {}
   // 自定义迭代器
   class iterator {
   public:
         int operator*() const { return 42; }
         iterator& operator++() { return *this; }
         bool operator!=(const iterator&) const { return false; }
   };
   iterator begin() const { return iterator(); }
   iterator end() const { return iterator(); }
};
// 自定义advance
void advance(iterator& it, int n) {
   std::cout << "Hidden::advance called" << std::endl;
}
}
void processRange() {
Hidden::Data data(100);
auto it = data.begin();
// 意图：调用std::advance
// 实际：ADL找到Hidden::advance
advance(it, 5);// 调用Hidden::advance，不是std::advance!
// 正确方式
std::advance(it, 5);// 明确调用std::advance
}
int main() {
processRange();
return 0;
}</pre></div>
<p class="maodian"></p><h3>4. 解决方案</h3>
<p class="maodian"></p><h4>4.1 使用完全限定名</h4>
<div class="jb51code"><pre class="brush:cpp;">namespace A {
class X {};
void process(X) {}
}
namespace B {
void test() {
   A::X x;
   // 避免ADL：使用完全限定名
   A::process(x);// 明确调用A::process
}
}</pre></div>
<p class="maodian"></p><h4>4.2 使用括号禁用ADL</h4>
<div class="jb51code"><pre class="brush:cpp;">namespace A {
class X {};
void process(X) {}
}
namespace B {
void process(int) {}
void test() {
   A::X x;
   // 使用括号阻止ADL
   (process)(x);// 错误：没有匹配的B::process
   // 只能找到B中的process，不会进行ADL
}
}</pre></div>
<p class="maodian"></p><h4>4.3 使用函数指针强制类型</h4>
<div class="jb51code"><pre class="brush:cpp;">namespace A {
class X {};
void process(X) {}
}
namespace B {
void test() {
   A::X x;
   // 使用函数指针指定类型
   void (*func_ptr)(A::X) = process;// ADL在初始化时发生
   // 或者使用auto
   auto func = static_cast<void(*)(A::X)>(process);
}
}</pre></div>
<p class="maodian"></p><h4>4.4 通用swap模式</h4>
<div class="jb51code"><pre class="brush:cpp;">// 正确的通用swap实现
template<typename T>
void genericSwap(T& a, T& b) {
using std::swap;// 将std::swap引入作用域
swap(a, b);    // 通过ADL选择最佳的swap
}
namespace MyLib {
class Widget {
   int* data;
   size_t size;
public:
   // ... 构造函数等 ...
   // 自定义swap（友元函数）
   friend void swap(Widget& a, Widget& b) noexcept {
         using std::swap;
         swap(a.data, b.data);
         swap(a.size, b.size);
   }
};
}
// 使用
int main() {
MyLib::Widget w1, w2;
genericSwap(w1, w2);// 正确调用MyLib::swap
return 0;
}</pre></div>
<p class="maodian"></p><h4>4.5 类型别名和ADL</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
namespace Original {
class Complex {
   double real, imag;
public:
   Complex(double r, double i) : real(r), imag(i) {}
   friend void print(const Complex& c) {
         std::cout << "Original::print" << std::endl;
   }
};
}
namespace Alias {
using Complex = Original::Complex;
void print(const Complex& c) {
   std::cout << "Alias::print" << std::endl;
}
}
int main() {
Original::Complex oc(1, 2);
Alias::Complex ac(3, 4);
print(oc);// 调用Original::print（ADL）
print(ac);// 调用Alias::print（ADL）
return 0;
}</pre></div>
<p class="maodian"></p><h3>5. ADL的高级技巧</h3>
<p class="maodian"></p><h4>5.1 利用ADL实现定制点</h4>
<div class="jb51code"><pre class="brush:cpp;">// 通用算法框架
namespace Framework {
// 定制点：允许用户通过ADL提供定制实现
template<typename T>
void custom_algorithm_impl(T& value);// 主要声明
// 默认实现
template<typename T>
void default_implementation(T& value) {
   std::cout << "Default implementation" << std::endl;
}
// 分发函数
template<typename T>
void custom_algorithm(T& value) {
   // 尝试通过ADL查找custom_algorithm_impl
   custom_algorithm_impl(value);
}
}
// 为特定类型提供定制
namespace User {
class MyType {
   int data;
public:
   MyType(int d) : data(d) {}
   friend void custom_algorithm_impl(MyType& mt) {
         std::cout << "User custom implementation: " << mt.data << std::endl;
   }
};
// 默认情况
template<typename T>
void custom_algorithm_impl(T& value) {
   Framework::default_implementation(value);
}
}
int main() {
User::MyType mt(42);
int regular_int = 100;
Framework::custom_algorithm(mt);    // 调用User定制版本
Framework::custom_algorithm(regular_int); // 调用默认版本
return 0;
}</pre></div>
<p class="maodian"></p><h4>5.2 ADL与CRTP模式</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
// CRTP基类
template<typename Derived>
class Printable {
public:
void print() const {
   // 通过ADL调用派生类的print_impl
   print_impl(static_cast<const Derived&>(*this));
}
};
// ADL查找函数
template<typename T>
void print_impl(const T& obj) {
std::cout << "Default print_impl" << std::endl;
}
// 派生类
class MyClass : public Printable<MyClass> {
int value;
public:
MyClass(int v) : value(v) {}
// 友元函数，通过ADL找到
friend void print_impl(const MyClass& mc) {
   std::cout << "MyClass: " << mc.value << std::endl;
}
};
int main() {
MyClass obj(42);
obj.print();// 通过ADL调用MyClass的print_impl
return 0;
}</pre></div>
<p class="maodian"></p><h4>5.3 ADL防护（SFINAE + ADL）</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <type_traits>
namespace Detail {
// 检测是否存在custom_swap
template<typename T>
auto has_custom_swap_impl(int) -> decltype(
   swap(std::declval<T&>(), std::declval<T&>()),// ADL查找
   std::true_type{}
);
template<typename T>
auto has_custom_swap_impl(...) -> std::false_type;
template<typename T>
constexpr bool has_custom_swap =
   decltype(has_custom_swap_impl<T>(0))::value;
}
// 安全的swap函数
template<typename T>
std::enable_if_t<Detail::has_custom_swap<T>>
safe_swap(T& a, T& b) {
using std::swap;
swap(a, b);// 使用ADL
}
template<typename T>
std::enable_if_t<!Detail::has_custom_swap<T>>
safe_swap(T& a, T& b) {
std::swap(a, b);// 回退到std::swap
}
namespace MyLib {
class Widget {
   int data;
public:
   Widget(int d) : data(d) {}
   friend void swap(Widget& a, Widget& b) {
         std::cout << "Custom swap" << std::endl;
         std::swap(a.data, b.data);
   }
};
}
int main() {
MyLib::Widget w1(1), w2(2);
int x = 10, y = 20;
safe_swap(w1, w2);// 使用自定义swap
safe_swap(x, y); // 使用std::swap
return 0;
}</pre></div>
<p class="maodian"></p><h3>6. 标准库中的ADL应用</h3>
<p class="maodian"></p><h4>6.1 std::begin和std::end</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <vector>
namespace Custom {
class Container {
   int data = {1, 2, 3, 4, 5};
public:
   // 自定义迭代器
   class iterator {
         int* ptr;
   public:
         iterator(int* p) : ptr(p) {}
         int& operator*() { return *ptr; }
         iterator& operator++() { ++ptr; return *this; }
         bool operator!=(const iterator& other) { return ptr != other.ptr; }
   };
   iterator begin() { return iterator(data); }
   iterator end() { return iterator(data + 5); }
};
// ADL查找的begin/end
auto begin(Container& c) { return c.begin(); }
auto end(Container& c) { return c.end(); }
}
// 通用范围for循环支持
template<typename T>
void processContainer(T& container) {
// 使用std::begin/std::end，但ADL可以找到自定义版本
using std::begin;
using std::end;
auto it = begin(container);
auto end_it = end(container);
for (; it != end_it; ++it) {
   std::cout << *it << " ";
}
std::cout << std::endl;
}
int main() {
Custom::Container c;
std::vector<int> v = {10, 20, 30};
// 范围for循环使用ADL查找begin/end
for (auto val : c) {// 调用Custom::begin/end
   std::cout << val << " ";
}
std::cout << std::endl;
processContainer(c);// 也能正确处理
return 0;
}</pre></div>
<p class="maodian"></p><h4>6.2 std::hash特化的ADL</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <unordered_set>
namespace MyTypes {
class Person {
   std::string name;
   int age;
public:
   Person(std::string n, int a) : name(std::move(n)), age(a) {}
   bool operator==(const Person& other) const {
         return name == other.name && age == other.age;
   }
   // 允许ADL找到hash特化
   friend struct std::hash<Person>;
};
}
// std::hash特化必须在std命名空间中
namespace std {
template<>
struct hash<MyTypes::Person> {
   size_t operator()(const MyTypes::Person& p) const {
         return hash<string>()(p.name) ^ hash<int>()(p.age);
   }
};
}
int main() {
std::unordered_set<MyTypes::Person> people;
people.insert(MyTypes::Person("Alice", 30));
people.insert(MyTypes::Person("Bob", 25));
// std::unordered_set会通过ADL找到std::hash特化
for (const auto& p : people) {
   std::cout << p.name << std::endl;
}
return 0;
}</pre></div>
<p class="maodian"></p><h3>7. 调试和诊断ADL问题</h3>
<p class="maodian"></p><h4>7.1 使用编译器诊断</h4>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
namespace A {
class X {};
void func(X) { std::cout << "A::func" << std::endl; }
}
namespace B {
void func(int) { std::cout << "B::func" << std::endl; }
void test() {
   A::X x;
   // 开启GCC/Clang的诊断
   // 编译命令：g++ -Wshadow -Wall -Wextra main.cpp
   // 有歧义的调用
   // func(x);// 如果B也有func(X)，这里会歧义
}
}
// 使用typeid检查ADL结果
#include <typeinfo>
template<typename T>
void checkADL(T value) {
using std::func;// 假设func存在
// 通过decltype检查调用哪个func
decltype(func(value)) result;
std::cout << "Function returns: " << typeid(result).name() << std::endl;
}</pre></div>
<p class="maodian"></p><h4>7.2 静态分析工具</h4>
<div class="jb51code"><pre class="brush:cpp;"># 使用clang-tidy检查ADL问题
clang-tidy main.cpp --checks='-*,readability-*'
# 使用cppcheck
cppcheck --enable=all main.cpp
# 生成预处理代码查看ADL查找
g++ -E main.cpp | grep -A5 -B5 "func"</pre></div>
<p class="maodian"></p><h3>8. 最佳实践总结</h3>
<p class="maodian"></p><h4>8.1 DOs and DON’Ts</h4>
<p><strong>DOs（应该做的）：</strong></p>
<ol><li><strong>理解ADL行为</strong>：知道何时会发生ADL</li><li><strong>使用完全限定名</strong>：当需要明确调用特定函数时</li><li><strong>遵循swap惯用法</strong>：在泛型代码中正确使用swap</li><li><strong>利用ADL进行定制</strong>：为库提供可定制的接口点</li><li><strong>使用using声明</strong>：在需要时引入特定函数到当前作用域</li></ol>
<p><strong>DON’Ts（不应该做的）：</strong></p>
<ol><li><strong>避免无意的ADL</strong>：当函数调用意图明确时，不要依赖ADL</li><li><strong>不要在头文件中污染命名空间</strong>：避免引起意外的ADL查找</li><li><strong>不要假设ADL顺序</strong>：不同编译器的ADL查找顺序可能不同</li><li><strong>避免隐藏的ADL依赖</strong>：明确文档化ADL依赖关系</li></ol>
<p class="maodian"></p><h4>8.2 设计指南</h4>
<div class="jb51code"><pre class="brush:cpp;">// 好的设计：明确的ADL接口
namespace Library {
// 可ADL查找的函数
void custom_algorithm_impl(MyType&);// 文档中说明
// 不可ADL查找的函数（内部使用）
namespace detail {
   void internal_helper(MyType&);
}
// 用户调用入口
template<typename T>
void process(T& value) {
   // 明确使用ADL进行定制
   custom_algorithm_impl(value);
}
}
// 用户扩展
namespace User {
class CustomType {
   // ...
};
// 通过ADL提供定制
void custom_algorithm_impl(CustomType& ct) {
   // 用户定制实现
}
}</pre></div>
<p class="maodian"></p><h4>8.3 团队规范</h4>
<ol><li><strong>文档化ADL依赖</strong>：在API文档中注明哪些函数会参与ADL</li><li><strong>代码审查关注点</strong>：审查泛型代码中的非限定函数调用</li><li><strong>测试策略</strong>：测试ADL相关的代码路径</li><li><strong>命名约定</strong>：为ADL接口使用一致的命名模式</li></ol>
<p class="maodian"></p><h3>9. 完整示例：安全的ADL使用框架</h3>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <type_traits>
#include <utility>
// 安全ADL框架
namespace SafeADL {
// 检测函数是否存在（通过ADL）
namespace detail {
   template<typename... Args>
   struct adl_detector {
         template<typename F>
         static auto test(int) -> decltype(
            std::declval<F>()(std::declval<Args>()...),
            std::true_type{}
         );
         template<typename>
         static auto test(...) -> std::false_type;
   };
   template<typename F, typename... Args>
   constexpr bool has_adl_function =
         decltype(adl_detector<Args...>::template test<F>(0))::value;
}
// 安全调用：优先ADL，否则使用默认
template<typename DefaultFunc, typename... Args>
auto safe_call(DefaultFunc default_func, Args&&... args) {
   // 尝试通过ADL调用
   if constexpr (detail::has_adl_function<DefaultFunc, Args...>) {
         // ADL版本存在
         return default_func(std::forward<Args>(args)...);
   } else {
         // 回退到默认版本
         static_assert(
            std::is_invocable_v<DefaultFunc, Args...>,
            "No viable function found via ADL or default"
         );
         return default_func(std::forward<Args>(args)...);
   }
}
// 安全的swap包装器
template<typename T>
void safe_swap(T& a, T& b) noexcept {
   safe_call(
         [](auto& x, auto& y) { std::swap(x, y); },// 默认实现
         a, b
   );
}
}
// 示例使用
namespace MyLib {
class Widget {
   int* data;
   size_t size;
public:
   Widget(size_t s) : data(new int), size(s) {}
   ~Widget() { delete[] data; }
   // 禁用拷贝（简化示例）
   Widget(const Widget&) = delete;
   Widget& operator=(const Widget&) = delete;
   // 允许移动
   Widget(Widget&& other) noexcept : data(other.data), size(other.size) {
         other.data = nullptr;
         other.size = 0;
   }
   // 自定义swap（通过ADL）
   friend void swap(Widget& a, Widget& b) noexcept {
         std::swap(a.data, b.data);
         std::swap(a.size, b.size);
         std::cout << "Custom swap called" << std::endl;
   }
};
// 另一个类没有自定义swap
class Simple {
   int value;
public:
   Simple(int v) : value(v) {}
};
}
int main() {
// 测试有自定义swap的类型
MyLib::Widget w1(10), w2(20);
SafeADL::safe_swap(w1, w2);// 调用自定义swap
// 测试没有自定义swap的类型
MyLib::Simple s1(1), s2(2);
SafeADL::safe_swap(s1, s2);// 调用std::swap
// 通用安全调用示例
int a = 10, b = 20;
SafeADL::safe_call(
   [](int x, int y) { return x + y; },
   a, b
);
return 0;
}</pre></div>
<p class="maodian"></p><h3>10. 总结</h3>
<p>ADL是C++中强大但危险的双刃剑。正确使用时，它能让代码更优雅、更灵活；错误使用时，会导致难以调试的问题。关键在于：</p>
<ol><li><strong>理解ADL何时发生</strong>：非限定函数调用 + 参数类型在命名空间中</li><li><strong>控制ADL影响范围</strong>：使用完全限定名或括号禁用不需要的ADL</li><li><strong>设计ADL友好的接口</strong>：明确哪些函数参与ADL查找</li><li><strong>遵循标准惯用法</strong>：特别是swap、begin/end等标准模式</li><li><strong>测试ADL相关代码</strong>：确保在不同上下文中行为正确</li></ol>
<p>通过谨慎使用和充分理解，ADL可以成为C++程序员工具箱中的有力工具，而不是隐藏的陷阱。</p>
<p>到此这篇关于C++ ADL(参数依赖查找)问题及解决方案的文章就介绍到这了,更多相关C++ ADL参数依赖查找内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！</p>

                        <div class="art_xg">
                           <b>您可能感兴趣的文章:</b><ul><li>记一次ADL导致的C++代码编译错误的原因及解决方法</li><li>VC++ loadlibrary()加载三方dll失败, 返回错误码:126的解决方法</li><li>C++依赖倒转原则和里氏代换原则有什么好处</li><li>C++设计模式中控制反转与依赖注入浅析</li><li>Conan中的C/C++的依赖管理</li><li>详解C++类的成员函数做友元产生的循环依赖问题</li></ul>
                        </div>

                     </div>

頁: [1]

琼殿技术论坛's Archiver

C++ ADL(参数依赖查找)问题及解决方案