Passing an entire object to access its private members

[BambiWithPMS]

I want to organize a private vector member by passing the entire object to a public function that is not inside any class.


I have a class Parent, class Child, and class Anon.

class Parent{
   virtual void print()=0;
};

class Child: public Parent{
   private:
      vector<Anon*> contain;   // The vector that I want to sort
   public:
      void print(){
         //print contain
      }

      void organize(){
         sort(this); //I want to give this entire object to another function that is not inside any class to sort it
      }
};

class Anon{
   private:
      int x;
   public:
      //accessors and mutators here...
};

void sort( Parent* c ){  //I will be creating multiple children to pass here
   
   for( vector<Anon*> it = c->contain.begin(); it!=c->contain.end(); it++)  //This is where I get most of my errors
//It says "class Parent has no member named contain". How do I let the program know which children to look into?

      //begin to sort elements
}

Is there a way for me to pass a variety of children into sort() and be able to sort it!

Any tips/guidance/advice is much appreciated.

[Ganado]

This is the definition of Parent:

class Parent{
   virtual void print()=0;
};

Parent does not have a member called "contain". It only has print(), as a pure virtual function.

I don't know exactly what your design constraints are, but if your Child class has a particular way of sorting, then make a function that accepts a Child object. And if you want this function to be able to directly access your contain vector, then you need to provide a getter, make it public, or make sort a friend. Again, it really depends on what your design requirements are, or what kinda of flexibility you want to provide.

#include <vector>

using std::vector;

class Parent {
   virtual void print()=0;
};

class Child;
void sort(Child& child);

class Anon;
class Child : public Parent {
   private:
      vector<Anon*> contain;
   public:
      void print(){
         //print contain
      }

      void organize(){
         sort(*this); 
      }
      
   friend void sort(Child& child);
};

class Anon {

};

void sort(Child& child) {
    for (Anon* element : child.contain)
    {
        // ...
    }
}

int main()
{
    Child child;
    child.organize();
}

If you need the sort function to take in a Parent pointer, then you should put the common data in the base class. e.g. put the vector in the base class, or make a "getContainer" virtual function.

If you told us what the actual purpose of this is, maybe someone could help come up with a design that doesn't seem contrived.

[Enoizat]

What’s bad in simply having your class which contains your std::vector sort it?

Example (mere draft):

#include <algorithm>
#include <iostream>
#include <numeric>
#include <random>
#include <vector>


class Parent {
public:
private:
    virtual void print() const = 0;
};


class Anon {
public:
    explicit Anon(int x_arg = 0);
    int getX() const;
    Anon& operator++();

private:
    int x;

//friend:
    friend bool operator< (const Anon& lhs, const Anon& rhs);
};


Anon::Anon(int x_arg)
    : x { x_arg }
{
}


Anon& Anon::operator++()
{
    ++x;
    return *this;
}


int Anon::getX() const
{
    return x;
}


bool operator< (const Anon& lhs, const Anon& rhs)
{
    return lhs.x < rhs.x;
}



class Child: public Parent {
public:
    void addElement(Anon* const value);
    void print() const override;

    void organize();

private:
    // Do not rely on raw pointers - take advantage of smart pointers or
    // std::reference_wrappers instead.
    // Also: can't you work out a better name than 'contain'?
    std::vector<Anon*> contain;
};


void Child::addElement(Anon* const value)
{
    contain.push_back(value);
}


void Child::print() const
{
    for(const auto* e : contain) {
        std::cout << e->getX() << ' ';
    }
}


void Child::organize()
{
    std::sort( contain.begin(),
               contain.end(),
               [](const Anon* const lhs, const Anon* const rhs) {
                   return lhs->getX() < rhs->getX();
               } );
}


void print(const std::vector<Anon>& what);


int main()
{
    std::vector<Anon> v(13);
    std::iota(v.begin(), v.end(), Anon(-6));
    std::shuffle(v.begin(), v.end(), std::mt19937 { std::random_device{}() } );
    std::cout << "v:\n";
    print(v);

    Child* one = new Child;
    for(auto& e : v) {
        one->addElement(&e);
    }

    one->organize();

    std::cout << "\none:\n";
    one->print();
    std::cout << '\n';
}


void print(const std::vector<Anon>& what)
{
    for(const auto& e : what) {
        std::cout << e.getX() << ' ';
    }
    std::cout << '\n';
}

Example output

v:
-2 -3 -1 5 4 2 -4 3 -5 -6 0 1 6

one:
-6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6