DOMANDA C++| Dubbio su shared_ptr

[Marcus Aseth]

Contesto: Ho questa classe Matrix qui:

#include <initializer_list>
#include <vector>
#include <memory>
#include <iostream>
using Array2D = std::vector<std::vector<double>>;

class Matrix
{
public:

    Matrix(unsigned rows, unsigned columns, std::initializer_list<double> elements);
    ~Matrix();

    inline unsigned rows()const { return _rows; }
    inline unsigned columns()const { return _columns; }
    inline std::shared_ptr<Array2D> matrix()const { return _matrix; }

    //Overloaded Operators
    friend inline std::ostream& operator<<(std::ostream& stream, const Matrix& M);
private:
    unsigned _rows;
    unsigned _columns;
    std::shared_ptr<Array2D> _matrix = nullptr;
};

notare la riga

 inline std::shared_ptr<Array2D> matrix()const { return _matrix; }

che ritorna un shared_ptr ad un vector<vector<double>> nell'heap.
Il problema con questo sistema è che nelle funzioni mi ritrovo a fare chiamate brutte da vedere, tipo

(*mM.matrix())[I][J++] = (*M.matrix())[i][j];

Se però modifico quel getter in

 inline Array2D& matrix()const { return *_matrix; }

allora posso scrivere

mM.matrix()[I][J++] = M.matrix()[i][j];

Che è più in linea con quello che vorrei ottenere.

Solo che non sono ancora tanto pratico con shared_ptr, quindi volevo sentire i vostri pareri per capire se è una buona idea o qualcosa che dovrei evitare, visto che mi pare che così sto bypassando la protezione offerta dallo shared_ptr.. :look::look:

Altra cosa, se invece scrivo Array2D senza il &

inline Array2D matrix()const { return *_matrix; }

il vector viene ritornato by value e quindi non è più un problema, giusto?

 

[signore del tempo]

Perché non lo rendi pubblico, se effettivamente è come se lo fosse? Inoltre, hai pensato ad un proxy object con overloaded operator[] ma la matrice privata?

 

[Marcus Aseth]

Perché non lo rendi pubblico, se effettivamente è come se lo fosse? Inoltre, hai pensato ad un proxy object con overloaded operator[] ma la matrice privata?

Bhe anche se fosse pubblico hai comunque uno shared_ptr, quindi stai comunque facendo dereference e poi access quindi lì non cambia molto, riguardo operator[] ci avevo pensato vagamente, ovvero mi ricordavo della possibilità ma non come dichiararlo, e per qualche ragione poi non avevo controllato, brainfart xD
Proverò, thanks :)

 

[signore del tempo]

Il fatto è che non ci puoi andare molto intorno ("bypassare" la cosa) giacché tu hai un puntatore, permettimi di dire di dubbia utilità, ad una matrice e i puntatori non sono array. Come dicevo, puoi affidarti ad un proxy object che maschererebbe un attimino la cosa.

 

[signore del tempo]

Dimenticavo, dai uno sguardo anche a librerie già esistenti per avere spunti sul design ;)