Witam,
na początku chce zaznaczyć, że jestem początkujący w C/C++,
mam za zadanie stworzyć jakiś alokator pamięci i wymyśliłem sobie, że skorzystam z szablonów w C++,
żeby np w metodzie push jako argument podać wartość zadeklarowanego wcześniej typu np:
Alok<string> alok;
alok.push("bang");
tutaj miałoby to zwracać nowo utworzoną zmienną tylko coś mi z tym nie idzie..
Nie wiem czy taki zapis to dobra alokacja pamięci:
T push(T value){
T obj;
obj = value;
return obj;
}
zacznij od czegos prostszego... powaznie. To zadanie Cie przerasta (tak bazujac to nad tym co napisales). To jest duzo bardziej skomplikowane niz Ci sie wydaje.
a przede wszystkim. Po co alokator pamieci?
Jeden z punktów zadania, nie musi spełniać wymagań i odpowiadać strukturze standardowych alokatorów.
Pytanie czy da się to w jakiś sposób uzyskać - chodzi tylko o alokacje i dealokacje pamięci oraz żeby zwracało obiekt zadanego typu.
Byłbym wdzięczy za jakieś wskazówki chociaż. :)
http://en.wikipedia.org/wiki/Allocator_(C%2B%2B)
http://en.cppreference.com/w/cpp/memory/allocator
powodzenia, przyda Ci sie ;)
W Effective STL było całkiem sporo o tym jak napisać customowy allocator (i kiedy tego [nie] robić, ale Ty raczej nie masz wyboru), poszukaj, fajnie opisane.
Zawsze możesz też pójść na skróty i poszukać gotowców (tylko i tak musisz wiedzieć co się tam dzieje, oraz ufać autorowi że jest dobrze): na przykład http://www.josuttis.com/cppcode/allocator.html :
/* The following code example is taken from the book
* "The C++ Standard Library - A Tutorial and Reference"
* by Nicolai M. Josuttis, Addison-Wesley, 1999
*
* (C) Copyright Nicolai M. Josuttis 1999.
* Permission to copy, use, modify, sell and distribute this software
* is granted provided this copyright notice appears in all copies.
* This software is provided "as is" without express or implied
* warranty, and with no claim as to its suitability for any purpose.
*/
#include <limits>
#include <iostream>
namespace MyLib {
template <class T>
class MyAlloc {
public:
// type definitions
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// rebind allocator to type U
template <class U>
struct rebind {
typedef MyAlloc<U> other;
};
// return address of values
pointer address (reference value) const {
return &value;
}
const_pointer address (const_reference value) const {
return &value;
}
/* constructors and destructor
* - nothing to do because the allocator has no state
*/
MyAlloc() throw() {
}
MyAlloc(const MyAlloc&) throw() {
}
template <class U>
MyAlloc (const MyAlloc<U>&) throw() {
}
~MyAlloc() throw() {
}
// return maximum number of elements that can be allocated
size_type max_size () const throw() {
return std::numeric_limits<std::size_t>::max() / sizeof(T);
}
// allocate but don't initialize num elements of type T
pointer allocate (size_type num, const void* = 0) {
// print message and allocate memory with global new
std::cerr << "allocate " << num << " element(s)"
<< " of size " << sizeof(T) << std::endl;
pointer ret = (pointer)(::operator new(num*sizeof(T)));
std::cerr << " allocated at: " << (void*)ret << std::endl;
return ret;
}
// initialize elements of allocated storage p with value value
void construct (pointer p, const T& value) {
// initialize memory with placement new
new((void*)p)T(value);
}
// destroy elements of initialized storage p
void destroy (pointer p) {
// destroy objects by calling their destructor
p->~T();
}
// deallocate storage p of deleted elements
void deallocate (pointer p, size_type num) {
// print message and deallocate memory with global delete
std::cerr << "deallocate " << num << " element(s)"
<< " of size " << sizeof(T)
<< " at: " << (void*)p << std::endl;
::operator delete((void*)p);
}
};
// return that all specializations of this allocator are interchangeable
template <class T1, class T2>
bool operator== (const MyAlloc<T1>&,
const MyAlloc<T2>&) throw() {
return true;
}
template <class T1, class T2>
bool operator!= (const MyAlloc<T1>&,
const MyAlloc<T2>&) throw() {
return false;
}
}
edit: z cppreference.com
W C++14 dochodzi jeszcze propagate_on_container_move_assignment
W C++17 prawdopodobnie dojdzieis_always_equal
Do C++11 wymaganiem było żeby wszystkie alokatory były stateless.
Gdyby ktoś mi ten przykład troche okroił to byłoby super!
Jeśli coś jest dla ciebie niezrozumiałe w kodzie, który wrzucił @msm to po prostu zapytaj.
Btw, skoro nie musisz implementować allocatora zgodnego z standardem, to na początek radziłbym zaimplementować prosty memory pool (stack-based).
satirev napisał(a):
Jeśli coś jest dla ciebie niezrozumiałe w kodzie, który wrzucił @msm to po prostu zapytaj.
Btw, skoro nie musisz implementować allocatora zgodnego z standardem, to na początek radziłbym zaimplementować prosty memory pool (stack-based).
Masz może jakiś przykład takiego memory pool'era ?
Przyznam, ze to cenna rada i na pewno będzie prościej niż z normalnym ustandaryzowanym alokatorem
