01/02/2020, 14:24
class Base{
int x;
};
Base& operator+(Base A,Base B){
Base* sum_Base{new Base};
sum_Base.x=A.x+B.x;
return *sum_Base;
}
01/02/2020, 17:53
01/02/2020, 18:05
auto result = a * b + c * d;
01/02/2020, 18:27
#include <iostream>
struct Base
{
Base( )
: x( 0 )
{
std::cout << "costruttore default\n";
}
explicit Base( int x )
: x( x )
{
std::cout << "costruttore con valore " << x << std::endl;
}
Base( const Base& B )
: x( B.x )
{
std::cout << "costruttore copia con valore " << x << std::endl;
}
~Base( )
{
std::cout << "distruttore elemento con valore " << x << std::endl;
}
int x;
};
Base&
operator+( Base A, Base B )
{
std::cout << "Operazione iniziata\n";
Base* sum_Base{new Base};
sum_Base->x = A.x + B.x;
std::cout << "Operazione finita\n";
return *sum_Base;
}
int
main( )
{
auto A = Base{3};
auto B = Base{5};
std::cout << "Prime allocazioni\n";
auto* C = &( A + B ); // per renderlo valido
std::cout << "Operazione conclusa\n";
std::cout << "Il risultato e' " << C->x << std::endl;
delete C;
}
02/02/2020, 12:52
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);
};
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;
};
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;
}
}
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);
}
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 }
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 }
02/02/2020, 16:04
04/02/2020, 01:54
anto_zoolander ha scritto:@Vict
ho ritornato un riferimento perché onestamente non sapevo come tenermi la memoria allocata visto che opero con zone di memoria.
[...]
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?
template<class T> List<T> operator-(const List<T>& a_List, const List<T>& b_List){
List<T> diff_List = a_List;
// ...
return std::move(diff_List);
}
anto_zoolander ha scritto:anzi se mi deste qualche esercizio tosto di python/c++ ve ne sarei grato.
04/02/2020, 15:09
apatriarca ha scritto: l'oggetto C ha una vita diversa per cui la sua memoria verrà deallocata in momenti diversi. Tuttavia la vita degli oggetti temporanei allocati nella funzione non cambia. La lista allocata dinamicamente in particolare non viene deallocata
apatriarca ha scritto: Nota che le due liste passate come argomento sono passate per riferimento e non per valore. Le stai inutilmente copiando
apatriarca ha scritto: Non sono sicuro che cosa intendi. Vuoi che inventiamo dei problemi da risolvere in C++ o Python? Hai dato un occhiata a siti come Codility? Vuoi qualcosa più sull'organizzazione del codice?
04/02/2020, 17:27
anto_zoolander ha scritto:Ho messo quel blocco in mezzo al nulla per chiarirmi un dubbio: un oggetto allocato dinamicamente all'interno di una funzione, e ritornato da essa il suo riferimento, ha lo scope della variabile che 'prende' questo oggetto.
#include <iostream>
struct A {
A() { std::cerr << "Create A\n"; }
A(const A& a) { std::cerr << "Copy A\n"; }
A(A&& a) { std::cerr << "Move A\n"; }
~A() { std::cerr << "Destroy A\n"; }
};
A& operator-(const A& a1, const A& a2)
{
A* result = new A;
return (*result);
}
int main(void)
{
A first;
A second;
A third{second - first};
}
Create A
Create A
Create A
Copy A
Destroy A
Destroy A
Destroy A
04/02/2020, 19:05
A third{second-first} ;
A& third{second - third} ;
Skuola.net News è una testata giornalistica iscritta al Registro degli Operatori della Comunicazione.
Registrazione: n° 20792 del 23/12/2010.
©2000—
Skuola Network s.r.l. Tutti i diritti riservati. — P.I. 10404470014.
Powered by phpBB © phpBB Group - Privacy policy - Cookie privacy
phpBB Mobile / SEO by Artodia.