白云网站建设多少钱_未成年高清在线观看_百度营销网页版_近一周的新闻大事热点

---

Item 41: Pass by Value for Copyable, Cheap-to-Move Parameters

Core Idea:

• Use pass-by-value when parameters are:
  1. Copyable (supports copy and move operations).
  2. Cheap to move (e.g., built-in types, small objects).
  3. Always copied (copied unconditionally inside the function).
• Avoids redundant copies when arguments are rvalues.

Example:

class Widget {  std::string name;  
public:  // Pass by value + move avoids one copy for rvalues.  Widget(std::string n) : name(std::move(n)) {}  
};  // Usage:  
Widget w1("Hello");       // Constructs from rvalue (efficient).  
std::string s = "World";  
Widget w2(s);              // Copies s into n, then moves to name.  

Test Case:

#include <iostream>  
#include <string>  class Widget {  
public:  std::string name;  Widget(std::string n) : name(std::move(n)) {  std::cout << "Widget constructed\n";  }  
};  int main() {  std::string s = "Test";  Widget w1(s);          // 1 copy (s → n), 1 move (n → name).  Widget w2("Hello");    // 0 copies (direct move from rvalue).  
}  

---

Item 42: Prefer Emplacement over Insertion

Core Idea:

• Use emplace_back/emplace instead of push_back/insert to:
  1. Avoid temporary object construction.
  2. Enable direct in-place construction.
• Exceptions:
  • When explicit conversions are needed (e.g., vector<Base> with Derived).
  • When container might reallocate (risk of resource leaks).

Example:

std::vector<std::string> vec;  
vec.push_back("Hello");     // Creates temporary std::string.  
vec.emplace_back("World");  // Constructs directly in place (no temporary).  

Test Case:

#include <vector>  
#include <string>  int main() {  std::vector<std::string> vec;  vec.reserve(2);  vec.push_back("Hello");  // Temporary string created → moved.  vec.emplace_back("World"); // Direct construction in memory.  
}  

---

Multiple-Choice Questions

1. When is pass-by-value NOT recommended?
   A) For std::unique_ptr parameters.
   B) For small, copyable types always copied.
   C) For parameters used conditionally.
   D) For types with expensive move operations.

2. Why prefer emplace_back over push_back?
   A) To avoid type conversions.
   B) To reduce temporary object constructions.
   C) To enforce explicit constructors.
   D) To prevent container reallocations.

3. Which scenario risks resource leaks with emplace?
   A) Using emplace_back with std::make_shared.
   B) Using emplace in a std::vector of integers.
   C) Using emplace with std::string in a non-reallocating vector.
   D) Using emplace with raw pointers.

4. What is the type of n in Widget(std::string n)?
   A) std::string&
   B) const std::string&
   C) std::string
   D) std::string&&

5. When does push_back outperform emplace_back?
   A) When constructing from an lvalue.
   B) When the container has sufficient capacity.
   C) When using explicit constructors.
   D) Never.

---

Design Questions

1. Design a function addToVector that takes a std::vector<std::string> and a string parameter, using optimal parameter passing.
2. Modify a std::vector<Base> to safely accept Derived objects via insertion/emplacement.
3. Implement a Logger class where pass-by-value avoids redundant copies.
4. Write a template function to forward arguments to emplace_back.
5. Identify and fix a resource leak in emplace usage with std::shared_ptr.

---

Answers & Explanations

Multiple-Choice Answers

1. C (Parameters used conditionally may incur unnecessary copies.)
2. B (emplace constructs in-place, avoiding temporaries.)
3. D (Raw pointers in emplace can leak if reallocation occurs.)
4. C (Pass-by-value creates a copy/moveable parameter.)
5. C (push_back ensures explicit conversions; emplace might bypass them.)

Design Answers

1. Optimal addToVector:

   void addToVector(std::vector<std::string>& vec, std::string s) {  vec.push_back(std::move(s));  // Move if possible.  
   }  
   

2. Safe Derived Insertion:

   std::vector<std::unique_ptr<Base>> vec;  
   vec.push_back(std::make_unique<Derived>());  // Safe insertion.  
   // vec.emplace_back(new Derived);            // Unsafe (potential leak).  
   

3. Logger Class:

   class Logger {  std::string data;  
   public:  Logger(std::string d) : data(std::move(d)) {}  
   };  
   

4. Emplace Forwarding:

   template<typename T, typename... Args>  
   void emplaceAdd(std::vector<T>& vec, Args&&... args) {  vec.emplace_back(std::forward<Args>(args)...);  
   }  
   

5. Fix Shared_ptr Leak:

   std::vector<std::shared_ptr<Widget>> vec;  
   vec.push_back(std::make_shared<Widget>());  // Safe.  
   // vec.emplace_back(new Widget);            // Risky (use make_shared).  
   

---

Test Cases

For Item 41:

int main() {  std::vector<std::string> vec;  std::string s = "Hello";  addToVector(vec, s);  // Copy + move.  addToVector(vec, "World");  // Direct move.  
}  

For Item 42:

int main() {  std::vector<std::unique_ptr<Base>> vec;  vec.reserve(10);  vec.push_back(std::make_unique<Derived>()); // Safe.  // vec.emplace_back(new Derived);           // Risk of leak.  
}  

This structured approach ensures mastery of parameter passing and emplacement optimizations in Modern C++!