Pardon per l'esempio, non è un qualcosa che ho implementato.
Vi riporto quello che ho fatto realmente(mi sto esercitando quindi provo ad inventarmi qualcosa).
@Vict
ho ritornato un riferimento perché onestamente non sapevo come tenermi la memoria allocata visto che opero con zone di memoria.
Testo nascosto, fai click qui per vederlo
anzi se mi deste qualche esercizio tosto di python/c++ ve ne sarei grato.
definizioni che possono essere utiliTesto nascosto, fai click qui per vederlo
- Codice:
template<class T> class List{
Node<T>* begin_p;
Node<T>* end_p;
size_t sz;
public:
List(List<T>& list);
List(std::initializer_list<T> lst); //initializer list
explicit List(); //default constructor
explicit List(size_t n); // n new nodes
~List(); // free all node
void append(T new_data); // new node after end
void insert(T new_data,size_t pos); //new data in pos
void remove(size_t pos); // delete node
void print() const; //print list
inline size_t size() const; // return length
bool operator==(List& lst);
T& operator[](size_t n);
};
i nodi sono oggetti che contengono informazioni di vario tipo
- Codice:
template<class T> struct Node{
T data;
Node* l_link; //from begin to end
Node* r_link; //from end to begin
Node(); // ++istance
~Node(); // --istance
inline static size_t get_istance();
private:
static size_t istance;
};
il distruttore della lista ha la seguente definizione
si occupa di deallocare ogni nodo quando si deve chiudere la lista.
- Codice:
template<class T> List<T>::~List(){
end_p=nullptr;
Node<T>* node_to_delete{};
while(begin_p!=nullptr){
node_to_delete=begin_p;
begin_p=begin_p->l_link;
delete node_to_delete;
}
}
l'esempio era praticamente il seguente
l'operatore rimuove dalla lista di sinistra gli elementi comuni con la lista di destra
- Codice:
template<class T> List<T>& operator-(List<T> a_List,List<T> b_List){
List<T>* diff_List{new List<T>{a_List}};
for(size_t i{a_List.size()} ; i>=1; --i){
size_t j{1};
while(j<=b_List.size() and a_List[i]!=b_List[j] )
++j;
if(j<=b_List.size())
(*diff_List).remove(i);
}
return (*diff_List);
}
quello che viene ritornato è il riferimento ad una lista
in questo caso quando si uscirà dall'ambito dell'oggetto ritornato la memoria verrà deallocata.
per esempio se compilo questo codice e setto un breakpoint alla riga 12, viene evocato il distruttore e dealloca la memoria.
- Codice:
1 #include "Listdef.cpp"
2
3 int main(void) {
4
5 List<int> A{1,2,3};
6 List<int> B{3,7};
7
8 {
9 List<int> C{B-A};
10 }
11
12 }
Quando si esce dall'ambito di
operator- vengono deallocate la zona di memoria occupata dal puntatore e la copia dei due oggetti i quali sono allocata sullo stack, diversamente accade per l'oggetto puntato che è allocato dinamicamente e quindi persiste uscendo dalla funzione, fino a quando non si esce dall'ambito di definizione dell'oggetto ritornato. E' corretto?
invece per il seguente frammento
- Codice:
1 #include "Listdef.cpp"
2
3 int main(void) {
4
5 List<int> A{1,2,3};
6 List<int> B{3,7};
7 List<int> C{};
8
9 {
10 C=B-A;
11 }
12
13 }
alla riga 11 l'oggetto la memoria non viene deallocata poiché il riferimento è passato ad un oggetto con scope più ampio.
PS: in questo caso le operazioni che vengono fatte per copiare gli oggetti all'interno della funzione sono parecchie e potrebbero essere allocati parecchi byte di memoria: non sarebbe meglio passare le liste per riferimento evitandosi tutte queste operazioni?