我怎样才能通过友谊正确到达我的功能？

Question

I have a abstract class like:

class Polygon {

public:
    vector < int > sides;

    virtual void circumreference()=0;
    virtual void print() = 0;
    void SaveAndRead() {
        save(sides);
        load(sides);
    }
    friend void save(std::vector < int >&);
    friend void load(std::vector < int >&);

};

save and load are out of class Polygon. I am trying to call function save and load in function SaveAndRead(), but I have errors like " save: ID not found" ," load: ID not found". Could somebody help me out with this? I will be grateful!

Answer 1

I understand that the save and load functions lay outside in an other class. In that case you should add the name of that class to your function definition.

friend void StoreFunctionClass::save(std::vector<int>&);

Answer 2

You cannot replace the regular declaration of save and load by only declaring them as friends of Polygon . That is, you must also declare them before Polygon .

Then, in order for your whole program to compile, you need to define save and load in a .cpp file.

Also you probably want save at least to take a const reference.

//polygon.hpp

#include <vector>

void save(const std::vector < int >&);
void load(std::vector < int >&);

class Polygon {

public:
    std::vector < int > sides;

    virtual void circumreference()=0;
    virtual void print() = 0;
    void SaveAndRead() {
        save(sides);
        load(sides);
    }
    friend void save(const std::vector < int >&);
    friend void load(std::vector < int >&);

};

// polygon.cpp
#include "polygon.hpp"

void save(const std::vector < int >&){
   // Code for save
}
void load(std::vector < int >&){
   // Code for load
}

---

Non related aspects:

• If load is used to initialize its argument, you probably want to return the vector by value.
• save and load seems to be good candidate to be actual members of Polygon . Friendship rarely is a good design choice.

---

More about the use of friend :

One typical use of friend is to implement iterators or any class intended to offer a specific "view" of another class. You want to give full access to this "view" class as it is conceptually part of the class it gives access to.

Some people also like to overload operator<< for streams using friend instead of defining a print public method called by the operator<< overload, which is acceptable.

Finally, commutative operators such as operator+ can be implemented either as a public member taking the other instance as argument or as a free friend function taking the two instances as arguments. The first approach is more concise while the second reflects the symmetry of the operator better.