## Question 11### Task: Develop a Function `allocate3`Create a function named `allocate3` that will dynamically allocate space for three integers, each initialized to 0. The function should manage memory carefully:```cpp// Preconditions: p1, p2, and p3 either point to dynamically created integers or are equal to nullptrvoid allocate3(int* &p1, int* &p2, int* &p3)```- **Functionality**: The function checks if the pointers `p1`, `p2`, and `p3` point to existing dynamic memory. If they do, it deletes that memory before allocating new memory. - **Exception Handling**: The function guarantees strong exception safety. If memory allocation fails and throws a `bad_alloc` exception, the function should throw that exception after ensuring no resource leaks occur.### Example Implementation```cppint *a, *b = nullptr, *c = nullptr;a = new int (2);allocate3(a, b, c); // Previous memory of `a` is deletedcout << *a << *b << *c << endl; // Outputs: 000int *x, *y = nullptr, *z = nullptr;x = new int (2);try { // Memory allocation for `y` throws bad_alloc below allocate3(x, y, z);} catch (bad_alloc) {}cout << *x << endl; // Outputs: 2```### Explanation- **Memory Management**: Before allocating new memory for `p1`, `p2`, and `p3`, the function deletes any existing dynamic memory they point to. - **Exception Safety**: The function ensures that if a `bad_alloc` exception occurs, the program's state remains consistent by handling exception safety rigorously.This design helps in efficient memory management and error handling in C++, especially when dealing with dynamic memory allocation.

Write a function called // Precondition: p1, p2 and p3 either point // to dynamically created integers or are // equal to nullptr void allocate3(int* &p1, int* &p2, int* &p3) that will dynamically allocate space for three integers initialized to 0. If the pointers already point to dynamic memory, that memory shoul be deleted. The function should have a strong exception guarantee. If any of the allocations fails by new throwing a bad_alloc exception, the function should also throw that exception after fulfilling its guarantee. int *a, *b = nullptr, *c = nullptr; a = new int (2); allocate3(a, b, c); // a’s previous memory is deleted cout << *a « *b << *c < endl; // prints 000 int *x, *y = nullptr, *z = nullptr; x = new int (2); try { // allocating memory for y throws badalloc below allocate3(x, y, z); } catch (bad_alloc) { } cout <« *x « endl; // prints 2

Write a function called // Precondition: p1, p2 and p3 either point // to dynamically created integers or are // equal to nullptr void allocate3(int* &p1, int* &p2, int* &p3) that will dynamically allocate space for three integers initialized to 0. If the pointers already point to dynamic memory, that memory shoul be deleted. The function should have a strong exception guarantee. If any of the allocations fails by new throwing a bad_alloc exception, the function should also throw that exception after fulfilling its guarantee. int a, b = nullptr, c = nullptr; a = new int (2); allocate3(a, b, c); // a’s previous memory is deleted cout << a « b << c < endl; // prints 000 int x, y = nullptr, z = nullptr; x = new int (2); try { // allocating memory for y throws badalloc below allocate3(x, y, z); } catch (bad_alloc) { } cout <« x « endl; // prints 2

Computer Networking: A Top-Down Approach (7th Edition)

7th Edition

ISBN:9780133594140

Author:James Kurose, Keith Ross

Publisher:James Kurose, Keith Ross

Chapter1: Computer Networks And The Internet

Section: Chapter Questions

Problem R1RQ: What is the difference between a host and an end system? List several different types of end...

See similar textbooks

Similar questions

Question 2 Choose the correct answer after considering the following statements: 1. A weak pointer can be used to delete the object to which it points if a temporary shared pointer is created from the weak pointer. 2. Proper use of weak pointers can prevent memory leaks. 3. Weak pointers observe and don't own resources. O Only 1 is true O Only 1 and 3 are true O Only 3 is true O Only 2 and 3 are true O Only 2 is true
// Description: Write a function Partition (f, l, p, a) // which partitions array a into two parts, left and right. // Elements of a in the left part should be smaller than p, // and the elements of a great than or eqaul to p should be in the right part. // F should set to the first element of a partition of array a to be partioned, // and l is the left element of a to be subjected to the partition. In C++ please, must include partition and swap functions
Problem 2: Create a ticket spin lock Complete the functions in ticket_spin_lock.cpp to implement a ticket lock that spins while waiting. Some useful hints: • The lock_t* lock struct containts the variables int ticket and int turn. • Use the atomic function_sync_fetch_and_add( int* ticket, int addition ). This function will atomically fetch the value in ticket and add addition to this value. • You may not need to do anything in the destroy function.
Help with c++...paste indented code plzz Write a function definition for a function named removeEnds to do the following: a. Accept an array A and the size of array A as parameters. b. Return a new dynamic array B which contains all but the first and last elements of the array A. c. Solution must use pointer arithmetic instead of [] notation. ExampleIf array A is 31,7,89,34,2, array B would be 7,89,34
plase give me code