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 should fırst 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 nullptr; int *x, *y = nullptr, *z = 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 should fırst 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 nullptr; int x, y = nullptr, z = X = new int (2); try { // allocating memory for y throws badalloc below allocate3(x, y, z); } catch (bad_alloc) { } cout <« x « endl; // prints 2

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

1. Write a function called void swap with two parameters, which will receive the addressof x and y as pointer. The function should swap the value of x and y only if x is larger thany. Print the value of x and y after the function call. 2. Write a function called double getAverage(int *array, int SIZE), whereit accept the array as pointer, and return the average of the array. Print the returnedvalue from this function. Always use *array rather than subscript to access the arrayvalue.
Given variables identifier, heat, and voltage, declare and assign the following pointers: • character pointer identifierPointer is assigned with the address of identifier. integer pointer heatPointer is assigned with the address of heat. double pointer voltagePointer is assigned with the address of voltage. Ex: If the input is M 132 5.5, then the output is: Product category: M Operational limit: 132 degrees at 5.5 volts. ● ● 1 #include 2 #include 3 using namespace std; 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int main() { Check char identifier; int heat; double voltage; V* Your code goes here */ cin cin >> heat; cin >> voltage; identifier; cout << "Product category: " << *identifierPointer << endl; cout << "Operational limit: " << *heatPointer << " degrees at "; cout << fixed <
1. Please explain in detail Scott Meyers’s point: Use weak_ptr for shared_ptr like pointers that can dangle. 2. How are Smart Pointer functions move(), reset(), and release() different from each other? Please also explain in detail which function is most dangerous and why? 3. Please explain in detail how to manually destroy an existing Smart Pointer control block.
Write an aligned malloc and free function that supports allocating memory such that the memory address returned is divisible by a specific power of two.EXAMPLEalign_malloc (1000, 128) will return a memory address that is a multiple of 128 and that points to memory of size 1000 bytes. aligned_ free () will free memory allocated by align_malloc.
In this assignment you are to use pointers to manipulate dynamically created arrays. An array's name is basically a pointer to the fisrt element of the array. Dynamic arrays are created using pointer syntax, but can subsequently use array syntax, which is the best practice approach. Instructions (main.cpp) Inside main.cpp implement the following functions: int makeArray (const int size); This function dynamically allocates an int array of the specified size. • size the size of the dynamically allocated array. • returns - a dynamically allocated integer array of size elements. void initializeArray (int * array, const int size, const int initValue); This function initializes an array of size elements with the initValue. array The array whose elements are to be initialized. size the size of the array. initValue the value with which to initialize each element. int duplicateArray (const int const sourceArray, const int size); This function duplicates an array of size elements. When copying…
Given variables category, heat, and voltage, declare and assign the following pointers: character pointer categoryPointer is assigned with the address of category. integer pointer heatPointer is assigned with the address of heat. double pointer voltagePointer is assigned with the address of voltage. Ex: If the input is C 355 3.5, then the output is: Product category: COperational limit: 355 degrees at 3.5 volts. #include <iostream>#include <iomanip>using namespace std; int main() { char category; int heat; double voltage; /* Your code goes here */ cin >> category; cin >> heat; cin >> voltage; cout << "Product category: " << *categoryPointer << endl; cout << "Operational limit: " << *heatPointer << " degrees at " << fixed << setprecision(1) << *voltagePointer << " volts." << endl; return 0;}
In this assignment you are to use pointers to manipulate dynamically created arrays. An array's name is basically a pointer to the fisrt element of the array. Dynamic arrays are created using pointer syntax, but can subsequently use array syntax, which is the best practice approach. Instructions (main.cpp) Inside main.cpp implement the following functions: int makeArray (const int size); This function dynamically allocates an int array of the specified size. • size the size of the dynamically allocated array. • returns - a dynamically allocated integer array of size elements. void initializeArray (int * array, const int size, const int initValue); This function initializes an array of size elements with the initValue. array-The array whose elements are to be initialized. size the size of the array. initValue the value with which to initialize each element. int duplicateArray (const int const sourceArray, const int size); This function duplicates an array of size elements. When copying…
Write a c++ function that accepts an array of doubles and the array’s size as its only arguments. The function should use dynamic memory allocation to create a new array that is double the size of the argument array. The function should copy the contents of the argument array to the second half of the new array and initialize the first half of the new 0s. The function should return a pointer to the new array. So, if the original array contained 1 2 3 4, the new array should contain 0 0 0 0 1 2 3 4. So, if the original array contained 1 2 3 4, the new array should contain 0 0 0 0 1 2 3 4.
Create a function that accepts an array of pointers as an argumentCreate one function that contains only one for loop to print the passed array of pointer.So, lines from //A to //B need to be replaced with only two function calls: one function call to printmonths (from the month array), and the second function call for printing the days (form the dayarray). Both function calls are for the same function but with different parameters.
Assume that pointer ptr is a pointer to a double, and has initial value of 0xfc0f. What is the value of ptr after the pointer has been decremented? (assume a 4 byte double) Group of answer choices 0xfb0e 0xfc13 0xfc0b 0xfc0e
Part II: Understand Pointers/Dynamic Memory To-do 2: Write 3 different functions in C++ to create memory on the heap without causing a memory leak. Hint: You will need to assign the address to a pointer that was created outside the function. Remember, you can return an address or change what a pointer points to (the contents of a pointer) in a function by passing the pointer by reference or by passing the address of the pointer. Additional questions: What if you want to change the contents of what the pointer points to? Make a function that will set the contents of the space on the heap. Do you still need to pass by reference or the address of the pointer? Why or why not? How will you delete the memory off the heap? Try doing it outside a function, and inside a function. Make sure your delete function is setting your pointer back to NULL, since it is not supposed to be pointing anywhere anymore. You can check to see if you have any memory leaks using valgrind. Svalgrind program_exe…
By using C , void fun(void* a, char*b) Write a defination of above function that accepts a function pointer and a character pointer (char*) as arguments. The function then calls a function whose pointer is passed as first argument by passing the second argument to it.