Bertrandt 理论题

Smart pointers were introduced in C++11 to assist with memory management and prevent memory leaks. The following questions address the allocation of memory for data used within the program, irrespective of type.

Briefly describe the difference between:

1. unique_ptr<>
2. shared_ptr<>
3. weak_ptr<>

1. A unique pointer (unique_ptr) is a smart pointer that will automatically deallocate the reserved memory as soon as it is out of scope. Only one unique_ptr can point to a resource, so it is illegal (at compile time) to make a copy of a unique_ptr.

2. A shared pointer (shared_ptr) is also a smart pointer that automatically deallocates the reserved memory once it is out of scope. However, a single resource can be simultaneously referenced by many shared pointers. An internal reference counter is used to keep track of the shared_ptr count for any given resource. If there are no references then the memory is freed. This is susceptible to the problem of circular dependency in cases where two or more shared pointers reference each other.

3. A weak pointer (weak_ptr) indeed references the memory, but is not able to use it before being converted into a shared pointer. This is done by using the lock() member function.  Using weak pointers is a common way to deal with the problem of circular dependencies. There is no reference count, but as such, the resource is first verified as soon as lock() is called. If the memory is still available then it is usable as a shared pointer. However, had it been deallocated previously then the lock() would fail.

In addition to the array functionality built into the language, the STL provides for a number of container classes. Two of these are List (std::list) and Vector (std::vector). What are the differences between these two container types, and in what circumstances would you choose one over the other?

The vector and list classes are both sequentially stored containers, but the internal implementation is significantly different. The vector is stored in contiguous memory locations like an array. A list, on the other hand, is stored internally as a doubly linked list. Both of these structures have their own caveats.

Vector

1. Insertion and deletion is expensive because:
2. If either occurs in the middle off the list then all of the elements have to be shifted, either to make room or to clear unused space.
3. If an element is added to the end then it may require re-allocation of memory and the copying of all of the elements.
4. C++ Iterators can be invalidated.
5. Random access is both possible and efficient, using the array operator (eg: tasks[12]).
6. Other STL algorithms that require Random Access Iterators can safely be used with the vector class. An example of this is std::sort(…), which on a vector can be called: std::sort(myVector.begin(), myVector.end());

List 

1. Insertion or deletion at any point (start, middle, end) only requires changing a few pointers. During insertion, of course, new memory will have to be allocated for the incoming element.
2. Random access is not possible in a list. In order to access the tasks in the previous example, tasks [12], it requires starting at the beginning of the list and iterating through the first 11 elements one at a time.
3. Iterators are not invalidated by list insertion or deleting because no element is moved from its position.
4. Random access iterators are by default invalid for lists. Consequently, custom functions using non-random access iterators need to be implemented. Due to how commonly lists are sorted, the functionality is part of the STL:
5. std::sort(..) does not work for lists; However, std::list::sort() is part of the STL

What is a class template? Comment on how using a template promotes code reuse.

A class template allows classes to be abstract in the sense that they do not know what datatype will be passed in and handled by its operations. A template does not depend on the characteristics of a particular datatype; rather, the focus is on the logic.

The std:vector template class is an example provided by the STL. It is generic because a vector of any datatype can be instantiated. This ability allows for efficient code reuse, and consequently the entire system is easier to implement and maintain.

The compilation of a C++ program involves three steps:

int getSum(int a, int b)
{
int bias = 3;
int sum;
auto lf = [&bias](int x, int y) { return x + y; };
 
// Calculate the sum using the lambda function
sum = lf(a, b);
 
return(sum);
}

class Solution
{
public:
    int maxProduct(vector<int>& nums)
    {
        sort(nums.begin(), nums.end(), greater<int>());
        return (nums[0] * nums[1]);
    }
};

class Solution
{
public:
    int maxProduct(vector<int>& nums)
    {
        int max1 = 0, max2 = 0;
        for(int i = 0; i < nums.size(); i++)
        {
            if(nums[i] >= max1)
            {
                max2 = max1;
                max1 = nums[i];
            }
            else if(nums[i] <= max1 && nums[i] > max2)
                max2 = nums[i];
        }
        return (max1 * max2);
    }
};