คำถามติดแท็ก smart-pointers

ตัวชี้อัจฉริยะคืออะไรและควรใช้เมื่อใด

1819 c++  pointers  c++11  smart-pointers  c++-faq 

std::unique_ptr มีการสนับสนุนสำหรับอาร์เรย์ตัวอย่างเช่น: std::unique_ptr<int[]> p(new int[10]); แต่มันจำเป็นหรือไม่ อาจจะมีความสะดวกมากขึ้นในการใช้หรือstd::vectorstd::array คุณพบว่ามีประโยชน์สำหรับการสร้างที่?

238 c++  c++11  smart-pointers  unique-ptr 

ตกลงดังนั้นครั้งสุดท้ายที่ฉันเขียน C ++ เพื่อหาเลี้ยงชีพ std::auto_ptrคือ std lib ทั้งหมดที่มีอยู่และboost::shared_ptrเป็นความเดือดดาลทั้งหมด ฉันไม่เคยมองไปที่การเพิ่มประเภทตัวชี้อัจฉริยะอื่น ๆ ฉันเข้าใจว่าตอนนี้ C ++ 11 มีการเพิ่มประเภทบางอย่าง แต่ไม่ใช่ทั้งหมด ดังนั้นใครบางคนจึงมีอัลกอริทึมง่าย ๆ ในการพิจารณาว่าจะใช้ตัวชี้สมาร์ทตัวไหน ควรรวมถึงคำแนะนำเกี่ยวกับพอยน์เตอร์พอยน์เตอร์ (พอยน์เตอร์ดิบเช่นT*) และสมาร์ทพอยน์เตอร์ที่เหลือ (บางอย่างเช่นนี้จะดีมาก)

228 c++  pointers  c++11  smart-pointers  c++-faq 

ความแตกต่างระหว่างพอยน์เตอร์ชุดต่อไปนี้คืออะไร? คุณใช้ตัวชี้แต่ละตัวในรหัสการผลิตเมื่อใด? ตัวอย่างจะได้รับการชื่นชม! scoped_ptr shared_ptr weak_ptr intrusive_ptr คุณใช้บูสต์ในรหัสการผลิตหรือไม่?

220 c++  boost  smart-pointers 

เกิดอะไรขึ้นกับโปรแกรมนี้ #include <memory> #include <vector> int main() { std::vector<std::unique_ptr<int>> vec; int x(1); std::unique_ptr<int> ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } ข้อผิดพลาด: In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64, from main.cpp:6: c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function 'void __gnu_cxx::new_allocator<_Tp>::construct(_Tp*, const _Tp&) [with _Tp = std::unique_ptr<int>, _Tp* …

217 c++  stl  c++11  smart-pointers  unique-ptr 

ในทางปฏิบัติกับ C ++ RAIIคืออะไรพอยน์เตอร์อัจฉริยะคืออะไรสิ่งเหล่านี้นำไปใช้ในโปรแกรมได้อย่างไรและประโยชน์ของการใช้ RAII กับพอยน์เตอร์อัจฉริยะคืออะไร

193 c++  smart-pointers  raii 

กับมาตรฐานใหม่ที่มา (และชิ้นส่วนอยู่แล้วในบางคอมไพเลอร์) รูปแบบใหม่ควรจะเป็นแทน std::unique_ptrstd::auto_ptr การใช้งานของพวกเขาทับซ้อนกันหรือไม่ (เพื่อให้ฉันสามารถค้นหา / แทนที่ทั่วโลกบนโค้ดของฉัน (ไม่ใช่ว่าฉันจะทำสิ่งนี้ แต่ถ้าฉันทำ)) หรือฉันควรตระหนักถึงความแตกต่างที่ไม่ชัดเจนจากการอ่านเอกสาร? นอกจากนี้ถ้ามันเป็นแทนโดยตรงทำไมให้มันชื่อใหม่มากกว่าแค่การปรับปรุงstd::auto_ptr?

185 c++  c++11  smart-pointers  auto-ptr  unique-ptr 

ฉันมีปัญหาในการทำความเข้าใจการใช้งานตัวชี้อัจฉริยะในฐานะสมาชิกคลาสใน C ++ 11 ฉันได้อ่านพอยน์เตอร์ที่ชาญฉลาดมากและฉันคิดว่าฉันเข้าใจวิธีการunique_ptrและshared_ptr/ หรือweak_ptrทำงานโดยทั่วไป สิ่งที่ฉันไม่เข้าใจคือการใช้งานจริง ดูเหมือนว่าทุกคนแนะนำให้ใช้unique_ptrเป็นวิธีที่จะไปเกือบตลอดเวลา แต่ฉันจะใช้บางสิ่งเช่นนี้ได้อย่างไร: class Device { }; class Settings { Device *device; public: Settings(Device *device) { this->device = device; } Device *getDevice() { return device; } }; int main() { Device *device = new Device(); Settings settings(device); // ... Device *myDevice = settings.getDevice(); // …

159 c++  c++11  shared-ptr  smart-pointers  unique-ptr 

ฉันอ่านบทความสองสามฉบับที่ไม่ควรใช้ตัวชี้แบบดิบ แต่ควรห่อด้วยพอยน์เตอร์พอยน์เตอร์เสมอไม่ว่าจะเป็นพอยน์เตอร์ที่กำหนดขอบเขตหรือแชร์ อย่างไรก็ตามฉันสังเกตเห็นว่าเฟรมเวิร์กอย่าง Qt, wxWidgets และไลบรารี่อย่าง Boost ไม่เคยกลับมาหรือคาดหวังว่าจะมีพอยน์เตอร์พอยน์เตอร์ราวกับว่าพวกเขาไม่ได้ใช้เลย พวกเขากลับมาหรือคาดหวังตัวชี้ดิบ มีเหตุผลอะไรบ้าง? ฉันควรอยู่ห่างจากตัวชี้สมาร์ทเมื่อฉันเขียน API สาธารณะและทำไม เพียงแค่สงสัยว่าเหตุใดจึงแนะนำสมาร์ทพอยน์เตอร์เมื่อโครงการสำคัญหลายโครงการดูเหมือนจะหลีกเลี่ยง

156 c++  api  pointers  smart-pointers 

ฉันได้อ่านซอร์สโค้ดของ Clangแล้วและฉันพบข้อมูลโค้ดนี้: void CompilerInstance::setInvocation( std::shared_ptr<CompilerInvocation> Value) { Invocation = std::move(Value); } ทำไมฉันจะต้องการที่จะ?std::movestd::shared_ptr มีจุดใดที่ถ่ายโอนความเป็นเจ้าของในทรัพยากรที่ใช้ร่วมกันหรือไม่ ทำไมฉันจะไม่ทำเช่นนี้แทน? void CompilerInstance::setInvocation( std::shared_ptr<CompilerInvocation> Value) { Invocation = Value; }

148 c++  c++11  shared-ptr  smart-pointers  move-semantics 

ไม่std::make_uniqueได้มีผลประโยชน์ใด ๆ เช่นประสิทธิภาพstd::make_shared? เมื่อเทียบกับการสร้างด้วยตนเองstd::unique_ptr: std::make_unique<int>(1); // vs std::unique_ptr<int>(new int(1));

130 c++  c++11  c++14  smart-pointers  unique-ptr 

การเปรียบเทียบข้อดีข้อเสียและเมื่อใดควรใช้? นี่คือการแยกออกจากเธรดการรวบรวมขยะที่สิ่งที่ฉันคิดว่าเป็นคำตอบง่ายๆสร้างความคิดเห็นจำนวนมากเกี่ยวกับการใช้งานตัวชี้อัจฉริยะบางอย่างดังนั้นจึงดูเหมือนว่าคุ้มค่าที่จะเริ่มโพสต์ใหม่ ในที่สุดคำถามคือการใช้งานตัวชี้อัจฉริยะใน C ++ มีอะไรบ้างและเปรียบเทียบกันอย่างไร ข้อดีข้อเสียหรือข้อยกเว้นง่ายๆเพียงอย่างเดียวและเข้าถึงสิ่งที่คุณอาจคิดว่าน่าจะใช้ได้ผล ฉันได้โพสต์การใช้งานบางอย่างที่ฉันเคยใช้หรืออย่างน้อยก็ปัดสวะและพิจารณาว่าใช้เป็นคำตอบด้านล่างและฉันเข้าใจถึงความแตกต่างและความคล้ายคลึงกันซึ่งอาจไม่ถูกต้อง 100% ดังนั้นอย่าลังเลที่จะตรวจสอบข้อเท็จจริงหรือแก้ไขฉันตามความจำเป็น เป้าหมายคือเพื่อเรียนรู้เกี่ยวกับออบเจ็กต์และไลบรารีใหม่ ๆ หรือแก้ไขการใช้งานของฉันและความเข้าใจเกี่ยวกับการใช้งานที่มีอยู่แล้วซึ่งใช้กันอย่างแพร่หลายและจบลงด้วยการอ้างอิงที่เหมาะสมสำหรับผู้อื่น

121 c++  smart-pointers  c++-faq 

มันยากที่จะบอกว่ากำลังถามอะไรที่นี่ คำถามนี้คลุมเครือคลุมเครือไม่สมบูรณ์กว้างเกินไปหรือมีวาทศิลป์และไม่สามารถตอบได้อย่างสมเหตุสมผลในรูปแบบปัจจุบัน สำหรับความช่วยเหลือในการทำความเข้าใจคำถามนี้เพื่อที่จะสามารถเปิด, ไปที่ศูนย์ช่วยเหลือ ปิดให้บริการใน8 ปีที่ผ่านมา C ++ เป็นข้อมูลเกี่ยวกับหน่วยความจำที่เป็นเจ้าของ - aka ความหมายเป็นเจ้าของ เป็นความรับผิดชอบของเจ้าของหน่วยความจำที่จัดสรรแบบไดนามิกเพื่อปลดปล่อยหน่วยความจำนั้น ดังนั้นคำถามจึงกลายเป็นว่าใครเป็นเจ้าของความทรงจำ ในความเป็นเจ้าของ C ++ จะถูกบันทึกโดยชนิดที่ตัวชี้ดิบถูกห่อไว้ภายในดังนั้นในโปรแกรม C ++ ที่ดี (IMO) จึงหายากมาก ( หายากไม่ใช่ไม่เคย ) ที่จะเห็นตัวชี้ดิบที่ส่งผ่านไปรอบ ๆ (เนื่องจากตัวชี้ดิบไม่มีการอนุมานความเป็นเจ้าของดังนั้นเราจึงสามารถ อย่าบอกว่าใครเป็นเจ้าของหน่วยความจำดังนั้นหากไม่ได้อ่านเอกสารอย่างรอบคอบคุณจะไม่สามารถบอกได้ว่าใครเป็นผู้รับผิดชอบในการเป็นเจ้าของ) ในทางกลับกันเป็นเรื่องยากที่จะเห็นตัวชี้ดิบที่เก็บไว้ในคลาสแต่ละตัวชี้ดิบจะถูกเก็บไว้ในกระดาษห่อตัวชี้อัจฉริยะของตัวเอง ( หมายเหตุ:หากคุณไม่ได้เป็นเจ้าของวัตถุคุณไม่ควรเก็บไว้เพราะคุณไม่สามารถรู้ได้ว่าเมื่อไรที่มันจะออกนอกขอบเขตและถูกทำลาย) ดังนั้นคำถาม: ผู้คนมีความหมายเกี่ยวกับความเป็นเจ้าของประเภทใด คลาสมาตรฐานใดบ้างที่ใช้ในการนำความหมายเหล่านั้นไปใช้ คุณคิดว่ามันมีประโยชน์ในสถานการณ์ใดบ้าง? ให้เก็บประเภทการเป็นเจ้าของทางความหมายไว้ 1 ประเภทต่อคำตอบเพื่อให้สามารถโหวตขึ้นและลงทีละรายการได้ สรุป: ตามแนวคิดแล้วตัวชี้ที่ชาญฉลาดนั้นเรียบง่ายและการนำไปใช้อย่างไร้เดียงสาทำได้ง่าย ฉันได้เห็นการพยายามใช้งานหลายครั้ง แต่มักจะใช้งานไม่ได้ในลักษณะบางอย่างที่ไม่ชัดเจนสำหรับการใช้งานทั่วไปและตัวอย่าง ดังนั้นฉันขอแนะนำให้ใช้ตัวชี้อัจฉริยะที่ผ่านการทดสอบอย่างดีจากไลบรารีแทนที่จะหมุนตัวเอง std::auto_ptrหรือหนึ่งในตัวชี้สมาร์ท Boost ดูเหมือนจะครอบคลุมทุกความต้องการของฉัน std::auto_ptr<T>: คนเดียวเป็นเจ้าของวัตถุ …

114 c++  memory-management  smart-pointers  ownership-semantics 

ค่าโสหุ้ยของตัวชี้อัจฉริยะเทียบกับพอยน์เตอร์ปกติใน C ++ 11 เป็นเท่าใด กล่าวอีกนัยหนึ่งรหัสของฉันจะช้าลงหรือไม่หากฉันใช้ตัวชี้อัจฉริยะและถ้าเป็นเช่นนั้นจะช้าลงเท่าใด โดยเฉพาะฉันถามเกี่ยวกับ C ++ 11 std::shared_ptrและstd::unique_ptr. เห็นได้ชัดว่าสิ่งที่ผลักลงในสแต็กจะมีขนาดใหญ่ขึ้น (อย่างน้อยฉันก็คิดอย่างนั้น) เนื่องจากตัวชี้อัจฉริยะจำเป็นต้องเก็บสถานะภายในไว้ด้วย (จำนวนอ้างอิง ฯลฯ ) คำถามก็คือสิ่งนี้จะเป็นเท่าใด ส่งผลกระทบต่อประสิทธิภาพการทำงานของฉันหรือไม่ ตัวอย่างเช่นฉันส่งคืนตัวชี้อัจฉริยะจากฟังก์ชันแทนที่จะเป็นตัวชี้ปกติ: std::shared_ptr<const Value> getValue(); // versus const Value *getValue(); หรือตัวอย่างเช่นเมื่อฟังก์ชันหนึ่งของฉันยอมรับตัวชี้อัจฉริยะเป็นพารามิเตอร์แทนที่จะเป็นตัวชี้ปกติ: void setValue(std::shared_ptr<const Value> val); // versus void setValue(const Value *val);

107 c++  performance  c++11  smart-pointers 

ตอนนี้ฉันรู้สึกหงุดหงิดมากหลังจากพยายามหาที่ตั้งของ shared_ptr อยู่หลายชั่วโมง ไม่มีตัวอย่างใดที่ฉันเห็นแสดงโค้ดที่สมบูรณ์เพื่อรวมส่วนหัวสำหรับshared_ptr(และใช้งานได้) เพียงแค่ระบุstd, tr1และ<memory>ไม่ได้ช่วยที่ทุกคน! ฉันดาวน์โหลดบูสต์แล้ว แต่ก็ยังไม่ปรากฏ! ใครช่วยบอกทีว่าหาได้ที่ไหน ขอบคุณที่ให้ฉันระบายความผิดหวัง! แก้ไข: ฉันเห็นว่าชื่อของฉันเปลี่ยนไป ขอโทษด้วยกับเรื่องนั้น. ดังนั้น ... มันยังเป็นเพราะฉันไม่ชัดเจนว่า shared_ptr "ขึ้นอยู่กับเวอร์ชัน C ++" -> นั่นเป็นสาเหตุที่ฉันไม่ระบุสภาพแวดล้อมของฉัน -> ดังนั้นจึงเป็นเรื่องยากสำหรับฉันที่จะค้นหามัน ฉันกำลังทำงานกับ MSVS2008 แก้ไข 2: ฉันไม่รู้ว่าทำไม แต่ฉันรวม [memory] และ [boost / tr1 / memory.hpp] และ [boost / tr1 / tr1 / memory] ในขณะที่มองหา shared_ptr ทุกที่ .. แน่นอนฉันทำไม่ได้ …

103 c++  boost  c++11  shared-ptr  smart-pointers