C++ Operator and Conversion Issues

double mean(vector<Reading> temps)
{
// stub version
    double mean_temp;
    double sum = 0;
    for (int i = 0; i< temps.size(); ++i) sum += temps[i];
    mean_temp = sum/temps.size();
    return (mean_temp);
}

double median(vector<Reading> temps)
{
// stub version
    double median_temp;
    sort (temps.begin(), temps.end());
    median_temp = temps[temps.size()/2];
    return (median_temp);
}

============================================

Result in errors:

proj4.cc: In function ‘double mean(Vector<Reading>)’:
proj4.cc:132: error: no match for ‘operator+=’ in ‘sum += temps.Vector<T>::operator[] [with T = Reading](((unsigned int)i))’
proj4.cc: In function ‘double median(Vector<Reading>)’:
proj4.cc:142: error: cannot convert ‘Reading’ to ‘double’ in assignment

=============================================

Full code below. I need to tackle these two errors before I can proceed

#include <bjarne/std_lib_facilities.h>

struct Reading {
    int hour;
    double temperature;
    Reading(int h, double t): hour(h), temperature(t) { }
    bool operator<(const Reading &r) const;
};

bool Reading::operator<(const Reading &r) const
{
// stub version

    vector<Reading> temps;
    sort (temps.begin(), temps.end());

}

/*
 * function declarations
 */

ostream& operator<<(ostream& ost, const Reading &r);

vector<Reading> get_temps();

double check_adjust_temp(double temperature, char scale);

double c_to_f(double temperature);

double mean(vector<Reading> temps);

double median(vector<Reading> temps);

void print_results(const vector<Reading>& temps, double mean_temp, 
           double median_temp);

int main()
    try
    {
        vector<Reading> temps = get_temps();
        if (temps.size() == 0) error("no temperatures given!");
        double mean_temp = mean(temps);
        sort(temps.begin(), temps.end());
        double median_temp = median(temps);
        print_results(temps, mean_temp, median_temp);
    }
    catch (exception& e) {
    cerr << "error: " << e.what() << '\n'; 
    return 1;
    }
    catch (...) {
    cerr << "Oops: unknown exception!\n"; 
    return 2;
    }

/*
 * function definitions
 */

ostream& operator<<(ostream& ost, const Reading &r)
{
// stub version

/*

 */
    return ost; 
}

vector<Reading> get_temps()
{
// stub version
    cout << "Please enter name of input file name: ";
   开发者_如何学JAVA string name;
    cin >> name;
    ifstream ist(name.c_str());
    if(!ist) error("can't open input file ", name);

    vector<Reading> temps;
    int hour;
    double temperature;
    while (ist >> hour >> temperature){
    if (hour <0 || 23 <hour) error("hour out of range");
    temps.push_back( Reading(hour,temperature));
    }

}

double check_adjust_temp(double temperature, char scale)
{
// stub version

    if (scale== 'c' || 'C'){

    return c_to_f(temperature);
    }
    else if (scale== 'f' || 'F')  {

    return temperature;
    }
    else {

    error("Wrong input type");
    }
}

double c_to_f(double temperature)
{
// stub version
    double c;
    c = ((temperature * (9.0/5)) + 32);
    return (c);
}

double mean(vector<Reading> temps)
{
// stub version
    double mean_temp;
    double sum = 0;
    for (int i = 0; i< temps.size(); ++i) sum += temps[i];
    mean_temp = sum/temps.size();
    return (mean_temp);
}

double median(vector<Reading> temps)
{
// stub version
    double median_temp;
    sort (temps.begin(), temps.end());
    median_temp = temps[temps.size()/2];
    return (median_temp);
}

void print_results(const vector<Reading>& temps, double mean_temp, 
           double median_temp)
{
// stub version
    cout << "The sorted temperatures are:\n";
    cout << get_temps;
    cout << "The mean temperature is " << mean_temp << ".\n";
    cout << "The median temperature is " << median_temp << ".\n";
}

---

Define a conversion operator for Reading:

struct Reading {
    int hour;
    double temperature;
    Reading(int h, double t): hour(h), temperature(t) { }
    bool operator<(const Reading &r) const;
    operator double() { return temperature; }
};

Or, better (via the Principle of Least Astonishment), just change the usage of your class:

// was:
sum += temps[i];
//change to:
sum += temps[i].temperature;

// was:
median_temp = temps[temps.size()/2];
//change to:
median_temp = temps[temps.size()/2].temperature;

---

You're trying to execute an addition between an instance of a class Reading and a double. This doesn't work as long as you don't provide either a default conversion path from Reading to double:

Reading::operator double() const { return temperature; }

or by providing proper global operator+() overloads:

double operator+(Reading const&, double);
double operator+(double, Reading const&);

The second error should be solvable with the Reading::operator double() as shown above.

---

You are missing operator+= for the class Reading

---

you are trying to sum up Reading objects into a double variable!

sum += temps[i];

sum type is double while temps[i] returns Reading object, you cannot sum double and Reading object since they belong to different types, you must define an overload of plus operator and make the compiler understand how this is done.