дружба и перегрузка операторов помощь

Question

У меня есть следующий класс

#ifndef Container_H 
#define Container_H 
#include <iostream> 
using namespace std; 

class Container{ 

    friend bool operator==(const Container &rhs,const Container &lhs); 
public: 
    void display(ostream & out) const; 

private: 
    int sizeC;    // size of Container 
    int capacityC;   // capacity of dynamic array 
    int * elements;   // pntr to dynamic array 
    }; 
ostream & operator<< (ostream & out, const Container & aCont); 
#endif 

и этот исходный файл,

#include "container.h" 

/*----------------------------********************************************* 
note: to test whether capacityC and sizeC are equal, must i add 1 to sizeC? 
seeing as sizeC starts off with 0?? 
*/ 

Container::Container(int maxCapacity){ 
    capacityC = maxCapacity; 
    elements = new int [capacityC]; 
    sizeC = 0; 
} 

Container::~Container(){ 
    delete [] elements; 
} 

Container::Container(const Container & origCont){ 
    //copy constructor? 
    int i = 0; 
    for (i = 0; i<capacityC; i++){ //capacity to be used here? 
     (*this).elements[i] = origCont.elements[i]; 

    } 
} 

bool Container::empty() const{ 
    if (sizeC == 0){ 
     return true; 
    }else{ 
     return false; 
    } 
} 

void Container::insert(int item, int index){ 
    if (sizeC == capacityC){ 
     cout << "\n*** Next: Bye!\n"; 
     return; // ? have return here? 
    } 
    if ((index >= 0) && (index <= capacityC)){ 
     elements[index] = item; 
     sizeC++; 
    } 
    if ((index < 0) && (index > capacityC)){ 
     cout<<"*** Illegal location to insert--"<< index << ". Container unchanged. ***\n"; 
    }//error here not valid? according to original a3? have i implemented wrong? 
} 

void Container::erase(int index){ 
    if ((index >= 0) && (index <= capacityC)){ //correct here? legal location? 
     int i = 0; 
     while (i<capacityC){ //correct? 
      elements[index] = elements[index+1]; //check if index increases here. 
      i++; 
     } 
     sizeC=sizeC-1; //correct? updated sizeC? 
    }else{ 
     cout<<"*** Illegal location to be removed--"<< index << ". Container unchanged. ***\n"; 
    } 
} 

int Container::size()const{ 
    return sizeC; //correct? 
} 

/* 
bool Container::operator==(const Container &rhs,const Container &lhs){ 
    int equal = 0, i = 0; 
    for (i = 0; i < capacityC ; i++){ 
     if (rhs.elements[i] == lhs.elements[i]){ 
      equal++; 
     } 
    } 

    if (equal == sizeC){ 
     return true; 
    }else{ 
     return false; 
    } 
} 

ostream & operator<< (ostream & out, const Container & aCont){ 
    int i = 0; 
    for (i = 0; i<sizeC; i++){ 
     out<< aCont.elements[i] << " " << endl; 
    } 
} 


*/ 

Я не имею другие функции в файле заголовка (просто quikie). В любом случае, последние две функции в «/ * * /» я не могу работать, что я делаю неправильно здесь?

первая функция, чтобы убедиться в том, что два массива равны друг другу

Answer 1

Когда вы объявляете функцию как friend внутри класса, функция является функцией, не являющееся членом, и как если бы это было объявленный в охватывающем пространстве имен. Таким образом, в вашем случае, ваше заявление о другом operator==,

class Container 
{ 
    friend bool operator==(const Container &rhs,const Container &lhs); 
}; 

является функцией, не являющееся членом, как если бы вы объявили его вне класса, например, так:

class Container 
{ 
}; 

bool operator==(const Container &rhs,const Container &lhs); 

Обратите внимание, что при вы объявляете функцию друга, функция также имеет доступ к закрытым членам класса, так что это не совсем то же самое.

Таким образом, ваше определение operator==, как если бы это была функция члена неправильно:

bool Container::operator==(const Container &rhs,const Container &lhs) { ... } 

должен быть

bool operator==(const Container &rhs,const Container &lhs) { ... } 

Как для перегрузки operator<<, это не друг Container, поэтому он не имеет доступа к частному elements члену Container. Либо сделайте operator<< знакомым, либо добавите в него публичных поставщиков доступа, чтобы они могли получить доступ к закрытым членам через них.

Answer 2

Есть некоторые проблемы с компиляцией, как уже указывал Джеймс, а также некоторые проблемы с дизайном. В каком случае, что означает, что для двух контейнеров равны? Тот же размер и ценность сохраненных объектов? Также емкость?

Во всяком случае, простой рефакторинг из operator== будет:

bool operator==(Container const & lhs, Container & rhs) 
{ 
    if (lhs.size() != rhs.size()) return false; 
    if (lhs.capacity() != rhs.capacity()) return false; // optional if same capacity is required 
    for (int i = 0; i < lhs.size(); ++i) { // Note: only check valid objects 
              // memory in [size,capacity) can or not be 
              // equal and should not affect the result 
     if (lhs[i] != rhs[i]) return false; 
    } 
    return true; // all tests passed 
} 

Отличия от вашей реализации (игнорируя тот факт, что вы пытались реализовать его как метод члена) является то, что эта версия будет не в состоянии быстро: Когда результат известен, он возвращается вызывающему. Нет необходимости проверять все элементы, если размеры отличаются. Кроме того, нет смысла сравнивать элементы, которые не присутствуют в контейнере. Если какой-либо элемент из [data[size], data[capacity]) совпадает в двух массивах, он добавит счет equals, влияющий на ваш результат.