allocation

I'm having trouble dynamically allocating memory for an array. I've been debugging for hours, any pointers? I posted the rest of the code. It is simply supposed to exchange the swap the first row with the second, and the third with the forth. I am getting strange results like: Enter string: hello Enter string: how are you Enter string: i'm good thanks Enter string: bye Enter string: bai Enter string: xx ========================= how are you !i'm good thanks hello !how are you bye !bai i'm good thanks !bye bai !xx int count = 0; char *lines[MAX_LINES]; char *tmp[50]; printf("Enter string: ");

Let's say I have: class A{ public: int x; int y; }; And I allocate an A instance like: A *a = new A(); Does a.x and a.y are also allocated in the heap, since they are 'dependent' of a heap allocated object? Thank you. It is important to understand that C++ uses "copy semantic". This means that variables and structure fields do not contain references to values, but the values themselves. When you declare struct A { int x; double yarr[20]; }; each A you will create will contain an integer and an array of 20 doubles... for example its size in bytes will be sizeof(int)+20*sizeof(double) and

I'm writing Rust bindings to a C library which has the option to use a third-party memory allocator. Its interface looks like this: struct allocator { void*(*alloc)(void *old, uint); void(*free)(void*); }; The corresponding Rust struct is, I guess, the following: #[repr(C)] #[derive(Copy, Clone, Debug, PartialEq)] pub struct Allocator { alloc: Option<extern "C" fn(*mut c_void, c_uint) -> *mut c_void>, free: Option<extern "C" fn(*mut c_void)>, } How can I implement these two extern functions that should mimic the allocator? I did not find anything really looking like the allocator API in Rust

This is something I've been wondering for a while and never found an answer for: Why is it that when you allocate something on the heap you cannot determine the size of it from just the pointer, yet you can delete it using just the pointer and somehow C++ knows how many bytes to free? Does this have something to do with the way it is stored on the heap? Is this information there but not exposed by C++? And perhaps this should be a separate question but I think it's pretty related so I'll ask it here: Why is it a dynamic array of elements must be deleted using delete [] as opposed to just the

Seems, that I found how to easily get normal 2D Array with contiguous memory in 2 lines of code: template<int N, int M> using Array2D = array<array<int, M>, N>; Let's solve easy task of swapping min and max in Array2D (a little of c++17): template<int N, int M> void printArray2D(const Array2D<N, M> &arr); int main() { const int N = 5; const int M = 5; Array2D<N, M> arr; // random init of Array2D generate(arr.front().begin(), arr.back().end(), []()->int { return rand() % 100; }); printArray2D(arr); auto[a, b] = minmax_element(arr.front().begin(), arr.back().end()); cout << "Swap minimum and

I just starting to learning vectors and little confused about size() and capacity() I know little about both of them. But why in this program both are different? even array(10) is making room for 10 elements and initializing with 0. Before adding array.push_back(5) So array.size(); is 10 that is ok. So array.capacity(); is 10 that is ok. After adding array.push_back(5) So array.size(); is 11 that is ok (already 10 time 0 is added and then push_back add one more element 5 ) . So array.capacity(); is 15 Why? ( is it reserving 5 blocks for one int? ) . #include <iostream> #include <vector> int