Перегрузка оператора индекса в пользовательском классе C ++ - PullRequest
Новая
       36

Перегрузка оператора индекса в пользовательском классе C ++

0 голосов
/ 17 ноября 2018

Рассмотрим следующий класс: 

class SocialPrefNode{

public:

// Constructors & Destructor
SocialPrefNode( );
SocialPrefNode( char self, int ind, int link, bool stack, std::vector<SocialPrefNode*> pref,
                std::vector<SocialPrefNode*> worse, std::vector<SocialPrefNode*> indiff );

SocialPrefNode( const SocialPrefNode& copy );

~SocialPrefNode( );

// Setters
void set_id( char self );

void set_index( int ind );
void set_lowlink( int link );

void set_onstack( bool stack );

void set_pref( std::vector<SocialPrefNode*> prefs );
void set_pref( SocialPrefNode& prefs );

void set_worse( std::vector<SocialPrefNode*> wrs );
void set_worse( SocialPrefNode& wrs );

void set_indiff( std::vector<SocialPrefNode*> indiff );
void set_indiff( SocialPrefNode& indiff );

// Getters
char get_id( ){ return id; }

int get_index( ){ return index; }
int get_lowlink( ){ return lowlink; }

bool get_onstack( ){ return onstack; }

std::vector<SocialPrefNode*> get_preferences( ){ return preferences; }
std::vector<SocialPrefNode*> get_worse( ){ return worsethan; }
std::vector<SocialPrefNode*> get_indiff( ){ return indifference; }

// Operators
SocialPrefNode& operator=( const SocialPrefNode& copy );

private:

char id{ };

int index{ };
int lowlink{ };

bool onstack{ };

std::vector<SocialPrefNode*> preferences{ };
std::vector<SocialPrefNode*> worsethan{ };
std::vector<SocialPrefNode*> indifference{ };
};

std::ostream& operator<<( std::ostream& os, SocialPrefNode& node );

Вопрос: Есть ли способ перегрузить / переопределить / переопределить индексный оператор s.t. например, можно иметь доступ к выбранному вектору из трех вариантов.

Т.е., предположим: SocialPrefNode ordering{ }. Я хочу иметь возможность использовать оператор индекса, как в ordering[ i ] И , чтобы иметь возможность выбрать один из трех векторов в классе, для которого индекс / индекс i будет работать.

Пример: каждый хочет получить доступ к третьему элементу в векторе preferences для SocialPrefNode ordering. Затем каждый ordering[ 2 ] и, таким образом, имеет доступ к нужному элементу.

1 Ответ

0 голосов
/ 17 ноября 2018

Возможное решение - использовать фантомные типы, чтобы обернуть вектор для использования.Я следил за этим сообщением в блоге и придумал следующее решение: 

// Wrapper need once in the complete project:
template <typename T, typename Parameter>
class NamedType
{
public:
    explicit NamedType(T const& value) : value_(value) {}
    explicit NamedType(T&& value) : value_(std::move(value)) {}
    T& get() { return value_; }
    T const& get() const { return value_; }
private:
    T value_;
};

// Only showing the new parts in your class!
class SocialPrefNode {
public:
    // One phantom type for each array index
    using preferences_index = NamedType<std::ptrdiff_t, struct preferences_Parameter>;
    using worsethan_index = NamedType<std::ptrdiff_t, struct worsethan_Parameter>;
    using indifference_index = NamedType<std::ptrdiff_t, struct indifference_Parameter>;

    // One operator[] for each array index type
    SocialPrefNode* operator[](preferences_index i) { return preferences[i.get()]; }
    SocialPrefNode* operator[](worsethan_index i) { return worsethan[i.get()]; }
    SocialPrefNode* operator[](indifference_index i) { return indifference[i.get()]; }
}

// Usage is simple assuming a SocialPrefNode s.
s[0]; // This will not work!
s[SocialPrefNode::preferences_index{ 0 }];  // Accessing preferences
s[SocialPrefNode::worsethan_index{ 0 }];    // Accessing worsethan
s[SocialPrefNode::indifference_index{ 0 }]; // Accessing indifference

Если вы не возражаете против добавления внешней зависимости, вы можете напрямую использовать Github repo автора NamedType (где класс немного расширен по сравнению с здесь).

...