一文詳解C++中的智能指針避坑指南
更新時間：2025年12月03日 08:30:26 作者：碼事漫談
你以為將new替換為make_shared就萬事大吉嗎,真相是智能指針的陷阱比手動管理更隱蔽更危險,本文將深入剖析循環(huán)引用,性能陷阱和線程安全,希望對大家有所幫助
你以為將new替換為make_shared就萬事大吉？真相是，智能指針的陷阱比手動管理更隱蔽、更危險。本文將深入剖析循環(huán)引用、性能陷阱、線程安全這三大「暗礁」，讓你從「自以為會」到「真正精通」。
一個經(jīng)典的崩潰代碼
如下代碼展露了智能指針中的循環(huán)引用問題。
// 這就是那個導致崩潰的簡化版代碼
class UserProfile {
std::shared_ptr<UserProfile> recommend_to; // 推薦給誰
// ... 其他數(shù)據(jù)
};
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
// 離開作用域后，引用計數(shù)永遠不會歸零！
// 內(nèi)存泄漏，最終OOM（內(nèi)存耗盡）
}
這就是智能指針最諷刺的地方：你為了避免內(nèi)存泄漏而使用它，結(jié)果它卻導致了更隱蔽的內(nèi)存泄漏。
錯誤一：循環(huán)引用——智能指針的「鬼打墻」
1.1 循環(huán)引用的典型場景
// 場景1：雙向關聯(lián)（父子節(jié)點）
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：緩存系統(tǒng)中的自引用
class CacheEntry {
std::shared_ptr<CacheEntry> next_in_lru; // LRU鏈表
std::shared_ptr<CacheEntry> prev_in_lru;
};
1.2 解決方案：weak_ptr的正確使用
// 正確方案1：使用weak_ptr打破循環(huán)
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不會增加引用計數(shù)
}
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的工作原理
// weak_ptr內(nèi)部機制模擬
template<typename T>
class WeakPtr {
private:
T* ptr_; // 指向?qū)嶋H對象
ControlBlock* control_block_; // 與shared_ptr共享的控制塊
public:
// lock()方法的實現(xiàn)
std::shared_ptr<T> lock() const noexcept {
if(control_block_ && control_block_->ref_count > 0) {
// 對象還活著，創(chuàng)建新的shared_ptr
return std::shared_ptr<T>(*this);
}
return std::shared_ptr<T>(); // 返回空shared_ptr
}
// 控制塊結(jié)構(gòu)
struct ControlBlock {
std::atomic<size_t> ref_count{1}; // 強引用計數(shù)
std::atomic<size_t> weak_count{1}; // 弱引用計數(shù)
T* object_ptr{nullptr};
~ControlBlock() {
if(ref_count == 0) {
delete object_ptr; // 只有強引用為0時才刪除對象
}
// weak_count為0時刪除控制塊本身
}
};
};
關鍵點：
weak_ptr不增加強引用計數(shù)，只增加弱引用計數(shù)- 對象銷毀的條件：強引用計數(shù) == 0
- 控制塊銷毀的條件：強引用計數(shù) == 0 且 弱引用計數(shù) == 0
1.4 循環(huán)引用檢測工具
// 運行時檢測工具
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>();
// ... 構(gòu)建可能循環(huán)的結(jié)構(gòu)
if(CyclicReferenceDetector::has_cycle(obj)) {
std::cerr << "WARNING: Memory leak due to cyclic reference!" << std::endl;
}
}
錯誤二：性能陷阱——你以為的「零成本」抽象
2.1 shared_ptr的隱藏成本
// 性能測試：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;
// 創(chuàng)建開銷
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 << "創(chuàng)建開銷:\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";
}
性能開銷來源：
- 控制塊分配：額外的一次內(nèi)存分配（除非用
make_shared） - 原子操作：引用計數(shù)的增減需要原子操作，影響多核性能
- 緩存不友好：對象和控制塊可能不在同一緩存行
- 虛函數(shù)開銷：自定義刪除器和分配器可能引入間接調(diào)用
2.2 make_shared vs shared_ptr構(gòu)造函數(shù)
// 關鍵區(qū)別：內(nèi)存布局
class LargeObject {
char data[1024]; // 1KB數(shù)據(jù)
};
void memory_layout_demo() {
// 方式1：兩次內(nèi)存分配
std::shared_ptr<LargeObject> p1(new LargeObject);
// 堆布局：[控制塊] ... [LargeObject]
// 兩次分配，可能內(nèi)存碎片
// 方式2：一次內(nèi)存分配（推薦）
auto p2 = std::make_shared<LargeObject>();
// 堆布局：[控制塊 + LargeObject]
// 單次分配，更好的局部性
// 但注意：weak_ptr會阻止整個內(nèi)存塊釋放
std::weak_ptr<LargeObject> weak = p2;
p2.reset(); // LargeObject析構(gòu)，但內(nèi)存直到weak銷毀才釋放
}
2.3 性能優(yōu)化策略
// 策略1：優(yōu)先使用unique_ptr
class ConnectionPool {
private:
// 池擁有所有連接
std::vector<std::unique_ptr<Connection>> connections_;
// 借出時返回原始指針或引用
Connection* borrow_connection() {
return connections_[next_available_].get();
}
// unique_ptr沒有引用計數(shù)開銷
// 所有權清晰，零額外成本
};
// 策略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) { // 直接傳遞引用
// 沒有引用計數(shù)操作
// 調(diào)用者需保證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 原子操作的性能影響
// shared_ptr引用計數(shù)的原子操作（簡化版）
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) {
// 內(nèi)存屏障！影響多核性能
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的線程安全層級
// shared_ptr的線程安全是分層的：
class ThreadSafetyLevels {
// 級別1：控制塊線程安全（標準保證）
// - 引用計數(shù)的增減是原子的
// - 不同的shared_ptr實例可以被不同線程安全地析構(gòu)
// 級別2：指向的數(shù)據(jù)線程不安全！
// - shared_ptr不保證其管理的對象的線程安全
// - 多個線程同時讀寫同一個對象需要外部同步
// 級別3：同一個shared_ptr實例的讀寫不安全！
// - 同一個shared_ptr對象被多個線程讀寫需要同步
};
// 證明：shared_ptr內(nèi)部不保護對象
void concurrent_access_problem() {
auto shared_data = std::make_shared<std::vector<int>>();
// 線程1：修改數(shù)據(jù)
std::thread t1([&shared_data]() {
for(int i = 0; i < 1000; ++i) {
shared_data->push_back(i); // 競態(tài)條件！
}
});
// 線程2：同時讀取
std::thread t2([&shared_data]() {
for(int i = 0; i < 1000; ++i) {
if(!shared_data->empty()) {
int value = shared_data->back(); // 可能讀取到無效數(shù)據(jù)！
}
}
});
t1.join();
t2.join();
// 結(jié)果：未定義行為！可能崩潰或數(shù)據(jù)損壞
}
3.2 典型線程安全問題
// 問題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沒有內(nèi)置的線程保護！
};
// 問題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; // 引用計數(shù)原子遞增
// 但p.reset()可能同時發(fā)生！
});
std::thread t2([&p]() {
p.reset(new int(100)); // 修改p本身需要同步！
});
t1.join();
t2.join();
// 這里有兩個獨立的數(shù)據(jù)競爭：
// 1. 對p本身的修改（shared_ptr對象）
// 2. 對新舊int對象的訪問
};
3.3 線程安全智能指針實現(xiàn)
// 方案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指向的內(nèi)容
// 但多個reader可能同時讀取，內(nèi)容本身需要保護
}
});
writer.join();
reader.join();
}
// 方案2：手動實現(xiàn)帶鎖的智能指針
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 多線程環(huán)境最佳實踐
// 最佳實踐1：使用不可變數(shù)據(jù)
class ImmutableData {
private:
const std::vector<int> data_; // 構(gòu)造后不可變
public:
// 線程安全：多個線程可以同時讀取
int get(size_t index) const {
return data_.at(index);
}
// 創(chuàng)建新版本而不是修改
std::shared_ptr<ImmutableData> with_addition(int value) const {
auto new_data = std::make_shared<ImmutableData>(*this);
// 注意：這里需要實際的不可變實現(xiàn)
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:
// 生產(chǎn)者：轉(zhuǎn)移所有權到隊列
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); // 所有權轉(zhuǎn)移給消費者
}
};
// 最佳實踐3：使用shared_ptr的別名構(gòu)造函數(shù)
class ThreadSafeObserver {
private:
std::shared_ptr<std::mutex> mutex_; // 共享的mutex
std::shared_ptr<Data> data_; // 共享的數(shù)據(jù)
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_的生命周期綁定在一起
}
// 創(chuàng)建觀察者副本
ThreadSafeObserver clone() const {
return ThreadSafeObserver(data_); // 共享相同的mutex和數(shù)據(jù)
}
};
綜合案例：一個線程安全、高性能的對象池
// 完整的最佳實踐示例
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_;
// 避免循環(huán)引用的關鍵：自定義刪除器
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;
}
}
// 創(chuàng)建新對象
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();
// 創(chuàng)建帶自定義刪除器的shared_ptr
std::shared_ptr<T> sp(raw_ptr, PoolDeleter{this});
// 存儲unique_ptr以管理生命周期
pool_.push_back(std::move(pooled_obj));
return sp;
}
private:
// 對象返回到池中（由自定義刪除器調(diào)用）
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;
// 創(chuàng)建新的weak_ptr添加到可用列表
available_.push_back(
std::shared_ptr<T>(std::shared_ptr<T>{}, ptr) // 別名構(gòu)造函數(shù)
);
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();
}
}
智能指針的三大「生存法則」
法則一：所有權設計優(yōu)先
- 能使用
unique_ptr就不要用shared_ptr - 明確對象的所有權生命周期
- 使用
weak_ptr打破循環(huán)引用
法則二：性能意識常駐
- 優(yōu)先使用
make_shared/make_unique - 避免不必要的
shared_ptr拷貝 - 注意原子操作的開銷
法則三：線程安全不假設
shared_ptr的線程安全僅限于控制塊- 指向的數(shù)據(jù)需要額外保護
- 考慮使用不可變數(shù)據(jù)結(jié)構(gòu)
最終檢查清單
每次使用智能指針前問自己：
1. 這個對象應該被誰擁有？
- unique_ptr
- shared_ptr
2. 是否有循環(huán)引用的可能？
- 有（需weak_ptr）
- 無
3. 是否會在多線程中使用？
- 是（需同步）
- 否
4. 是否需要最優(yōu)性能？
- 是（避免shared_ptr）
- 否
5. 是否傳遞所有權？
- 是（移動語義）
- 否（傳遞引用）
從「會用」到「精通」
智能指針不是「銀彈」，而是「雙刃劍」。它解決了手動管理內(nèi)存的煩惱，卻引入了更隱蔽的陷阱。真正的精通，不是記住語法，而是理解每個設計決策背后的權衡。
正如C++之父Bjarne Stroustrup所說：「C++的設計初衷是讓好的設計更容易，壞的設計更困難」。智能指針正是這一哲學的體現(xiàn)——它獎勵清晰的所有權設計，懲罰模糊的資源管理。
下次當你寫下std::shared_ptr時，不妨停頓一秒，問問自己：「我真的需要共享所有權嗎？」這個簡單的問題，可能就是避免下一個深夜崩潰的關鍵。
到此這篇關于一文詳解C++中的智能指針避坑指南的文章就介紹到這了,更多相關C++智能指針內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了C++中的析構(gòu)函數(shù),為C++入門學習中的基礎知識,需要的朋友可以參考下2016-01-01
C++面向?qū)ο蠖嗉壊藛蜗駻rduino的移植問題小結(jié)
這篇文章主要介紹了C++面向?qū)ο蠖嗉壊藛蜗駻rduino的移植問題及實現(xiàn)思路,本文通過示例代碼給大家介紹的非常詳細,感興趣的朋友跟隨小編一起看看吧2024-06-06
這篇文章主要為大家詳細介紹了C語言實現(xiàn)旅游資訊管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-03-03
交叉編譯就是在當前系統(tǒng)平臺上,開發(fā)編譯運行于其它平臺的程序,比如本文硬件環(huán)境是x86平臺,但是編譯出來的程序是在arm64架構(gòu)、mips64等架構(gòu)上運行,本文給大家分享QT5交叉編譯入門級教程(arm64、mips64),感興趣的朋友一起看看吧2023-11-11
Qt數(shù)據(jù)庫應用之實現(xiàn)通用數(shù)據(jù)庫分頁
數(shù)據(jù)庫分頁展示，在所有的涉及到數(shù)據(jù)庫記錄的項目中都是需要的。本文將利用Qt實現(xiàn)通用數(shù)據(jù)庫的分頁展示，感興趣的小伙伴可以跟隨小編學習一下2022-02-02
C++調(diào)用迅雷接口解析XML下載功能(迅雷下載功能)
這篇文章主要介紹了C++調(diào)用迅雷接口，封裝解析XML下載的類，功能簡單，大家參考使用吧2013-11-11
C++17中的結(jié)構(gòu)化綁定(structured binding)是指將指定名稱綁定到初始化程序的子對象或元素,本文主要來和大家聊聊C++17中結(jié)構(gòu)化綁定的實現(xiàn),感興趣的小伙伴可以了解下2023-12-12
這篇文章主要介紹了C語言中的memset()函數(shù),包括其與memcpy()函數(shù)的區(qū)別,需要的朋友可以參考下，希望能夠給你帶來幫助2021-09-09
使用memcpy拷貝vector中自定義類型元素（如string）時,僅復制指針值導致懸空指針,引發(fā)未定義行為,而循環(huán)賦值通過調(diào)用賦值運算符實現(xiàn)深拷貝,正確復制對象內(nèi)容,標準庫vector通過類型特質(zhì)區(qū)分類型,對非平凡類型調(diào)用構(gòu)造/析值函數(shù),避免此類問題2025-09-09
這篇文章主要介紹了如何理解C++指針常量和常量指針，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-06-06