Template overload of insertion operator >> causing cin issue

Question

so I've got a project where I am inserting user entered data into classes. So I've overloaded the >> operator. Because I have classes with similar structures, I made the overload a template to try to save time. Making this template overload a friend of the classes seems to work, as I get no compile errors.

My ClassDefs.h:

// ClassDefs.h

using namespace std;

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <tuple>
#include <map>
#include <typeinfo>

class measurement {

    //friends

    template<class measT>   //measT are other similar measurement classes
    friend istream & operator >> (istream&, measT&);


private:
    string words;

public:
    //constructors and things like that here

};

template<class measT>
istream& operator >> (istream& is, measT& meas) {

    //a series of checks to ensure user entry is valid

    //enter user entry into private data
    //e.g. 

    string line;
    getline(is,line);

    meas.words = line;

    return is;

}

The problem comes when using cin >> foo in main - I get a warning caption saying "more than one operator >> matches these operands". Accompanied by:

error C2593: 'operator >>' is ambiguous

This makes sense, but my crude understanding of overloads was that they allow you to use different types with that operator and the compiler "understands" which definition to use for each situation.

My main.cpp:

// main.cpp

#include "ClassDefs.h"

int main(){

    string entry;
    cin >> entry;
        ^^ error here

    return 0;
}

I have looked around and seen things involving explicit, inline, namespace (my using namespace std; seems dodgy) but I haven't seen anyone use this template overload arrangement and have this problem. I'm using Visual Studio 2015 Community.

Any help or advice would be greatly appreciated :)

`istream& operator >> (istream& is, measT& meas)` is a wide-open template. It will specialize for *anything*. `measT` hasn't been forced to be a `measurement ` or subclass, so `std::string` fits just fine, upsetting the compiler. You may be able to just ditch the template and use polymorphism, but you haven't provided enough info for me to be sure. — user4581301, May 11 '17 at 05:10
@user4581301 so is there a way to force measT to be one of a few possible classes? — Nikomai Hurashi, May 11 '17 at 05:25
I know of no tricks that will work the way it looks like you need, but templates are my strong point. If these few possible classes are subclasses, or can be made subclasses of `measurement`, you can make it work without the template. — user4581301, May 11 '17 at 05:48
@user 4581301 ah brilliant, they are subclasses of an abstract base class! So could I do something like `istream& operator >> (istream& is, measurement& meas)` if measurement was the base class? — Nikomai Hurashi, May 11 '17 at 06:11
Should work. Though you should make a small modification to comply with convention and make the function applicable to more cases:`istream& operator >> (istream& is, const measurement& meas)` — user4581301, May 11 '17 at 06:44

Nikomai Hurashi · Accepted Answer · 2017-05-13T00:10:04.883

So I solved this partially with the help of @user4581301 - I really needed to keep the >> overload a template so that I could use that parameter for a template exception class inside it.

It has become a bit convoluted but I thought I'd share in case anyone else is having issues overloading operators with templates.

Firstly I changed measurement from an abstract base class to a base class (so that it could be used as a template parameter) and changed the friend declaration inside to:

//ClassDefs.h

template <class measT>  
friend istream& operator >> (istream&, measurement&);

Where measT was the type of measurement involved, to be used as the parameter for the exception class.

Then later on in the header file, >> was overloaded with the definition:

//ClassDefs.h

template<class measT>
istream& operator >> (istream& is, measurement& meas) {

//take user input
//do checks on it, throw Exception<measT> depending on which set of 
  exceptions are relevant
}

And most importantly I wasn't sure how to use an operator with a template parameter but it turns out you can do it explicitly:

//ClassDefs.h

template<class measT>
measT userNewMeas() {    //function to take user input and make into a type 
                         // of measurement

    try    { ::operator>><measT> (cin,newMeas); }
    catch  (Exception<measT>& error) {
        cout << error << endl;    // this output depends on which exception 
                                  // was called
    }

And now I can use template userNewMeas() in main.cpp with template >> and template Exception. The goal is probably hard to see for everyone but I was trying to overload >> for any measurement type, and have one Exception class containing different error messages to be thrown depending on which measurement was being entered.

Template overload of insertion operator >> causing cin issue

1 Answers1