I have a class Graph with constructor and overloaded operator <<, graph.h:
class Graph
{
private:
vector<int> setOfVertices;
public:
Graph(ifstream &); //konstruktor ze souboru
friend ofstream & operator<<(ofstream&, const Graph &);
};
the definition of constructor(not important for minimal example) and operator << are in separated file graph.cpp:
ofstream & operator<<(ofstream& outputStream, const Graph & graphToPrint)
{
//not important for minimal example
return outputStream;
}
When I try to call operator << in main.cpp:
#include <iostream>
#include <fstream>
#include "graph.h"
using namespace std;
int main()
{
ifstream myFile ("example.txt");
Graph * G = new Graph(myFile);
cout << *G;
return 0;
}
I get an error
error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'Graph' (or there is no acceptable conversion)
I didn't manage to locate the mistake in the code by myself, I will be thankful for every piece of advice.
std::cout is a global object of type std::ostream not std::ofstream. std::ofstream is a derivative of std::ostream. See http://en.cppreference.com/w/cpp/io/cout
So, modify your friend function (operator) to
friend ostream & operator<<(ostream&, const Graph &);
Related
I am fairly new to classes. I created a class called Counter which basically creates a counter object and has certain data members and function members associated with it.
The header file for the class is:
#ifndef c
#define c
#include <iostream>
#include <string>
#include <vector>
using std::vector; using std::string; using std::ostream;
class Counter{
int v_;
public:
vector<string> log_;
int initialized_;
Counter(int);
int value();
int get_v() const { return v_; } //getter
void set_v(int val) { v_ = val; } //setter
friend ostream & operator<<(ostream &, Counter &);
friend Counter operator+(const Counter &, const Counter &);
};
ostream & operator<<(ostream &, Counter &);
Counter operator+(const Counter &, const Counter &);
#endif
and the cpp implementation file looks like this:
#include "counter.h"
#include <iostream>
#include <vector>
#include <string>
using std::string; using std::vector; using std::ostream;
Counter::Counter(int a){
v_ = a;
initialized_ = a;
log_.push_back("Constructor called with a " + std::to_string(a));
}
int Counter::value(){
log_.push_back("value called. returned a " + std::to_string(v_));
return (v_--);
}
ostream & operator<<(ostream & out, Counter & c){
c.log_.push_back("<< called."); //line 1
out << "Counter("<< c.initialized_ << ")#" << c.v_; //line 2
return out;
}
Counter operator+(const Counter & c_one, const Counter & c_two){
Counter c_three(c_one.initialized_ + c_two.initialized_);
c_three.set_v(c_one.get_v()+c_two.get_v());
return c_three;
}
When I compile the file I get bombarded with expected primary-expression before ‘.’ token in line 1 and line 2 of the "<<" operator overloaded function. I really have no idea as to why this is happening. Any help?
What is c? You've defined it as nothing and then you use
c.log_.push_back(...)
Which the preprocessor changes to
.log_.push_back(...)
I'm not sure what you're trying to do but the error clearly states it's looking for an expression before the period, where it appears you have none.
Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 3 years ago.
Improve this question
I have been stuck on what to do with this for loop inside an istream operator, i dont understand why it doesnt find >> operator.
Error C2679 binary '>>': no operator found which takes a right-hand operand of type 'Result' (or there is no acceptable conversion)
any help would be madly appreciated.
#include "pch.h"
#include <iostream>
#include <fstream>
#include "Unit.h"
#include "Registration.h"
istream & operator >>(istream & input, Unit & U);
ostream & operator <<(ostream & os, const Unit & U);
istream & operator >>(istream & input, Result & Re);
ostream & operator <<(ostream & os, const Result & Re);
istream & operator >>(istream & input, Date & D);
ostream & operator <<(ostream & os, const Date & D);
int main()
{
std::cout << "Hello World!\n";
ifstream infile("rinput.txt");
if (!infile)
{
return -1;
}
Registration R;
infile >> R;
ofstream ofile("routput.txt");
ofile << R
<< "Number of units = " << R.getCount() << '\n'
<< "Total credits = " << R.GetCredits() << '\n';
infile.close();
ofile.close();
}
#include "Registration.h"
using namespace std;
Registration::Registration()
{
}
istream & operator >>(istream & input, Registration & R)
{
long idTemp;
unsigned semesterTemp, countTemp;
Registration regTemp;
Result tempResult;
input >> idTemp >> semesterTemp >> countTemp;
regTemp.setStudentId(idTemp);
regTemp.setSemester(semesterTemp);
regTemp.setCount(countTemp);
for (unsigned i = 0; i < R.getCount(); i++)
{
//THIS LINE IS THE ERROR
input >> tempResult;
R.setResult(i, tempResult);
}
return input;
}
//result h file has the following
#ifndef RESULT_H
#define RESULT_H
#include "Date.h"
#include "Unit.h"
class Result
{
public:
Result();
float getMark() const;
void setMark(float mrk);
int GetCredits() const;
const Date & getDate() const;
void setDate(const Date &D);
const Unit & getUnit() const;
void setUnit(const Unit &U);
private:
float mark;
Date dateObject;
Unit unitObject;
};
#endif // !RESULT_H
this is the error:
Severity Code Description Project File Line Suppression State
Error C2679 binary '>>': no operator found which takes a right-hand operand of type 'Result' (or there is no acceptable conversion)
each class that is referenced inside result also has an overloading input stream function.
Here is a simple example
namespace Me {
class A
{
// bla
};
std::ostream& operator<<(std::ostream& os, A& const& obj)
{
// print in terms of public interface of A
// (else, deckare this a friend function inside A)
return os;
}
} // Me
int main()
{
std::cout << A(); // operator<<(ostream&, A const&) is the best match
}
C++ doesn't really have "source" or "header" files, it deals only with translation units.
A translation unit is, in short, a single source file with all included header files. Most importantly, a translation unit is its own independent unit, without any knowledge of other translation units.
That means declarations put in one translation unit (source file) will now be known by a different translation unit.
For a declaration to be known to all translation units that are linked into the final executable program, you should put them in a header file that is included everywhere needed.
Example:
Header file result.h:
#ifndef RESULT_H
#define RESULT_H
class Result
{
// ...
};
std::istream & operator >>(std::istream & input, Result & C);
std::ostream & operator <<(std::ostream & os, const Result & C);
#endif
"Main" source file main.cpp:
#include <iostream>
#include "result.h" // "Import" the `operator>>` declaration
int main()
{
Result result;
std::cin >> result;
}
"Result" class implementation source file result.cpp
#include <iostream>
#include "result.h"
// Result class implementation...
std::istream & operator >>(std::istream & input, Result & C)
{
// Read input...
return input;
}
When building the above example, you build the two source files separately as two separate translation units. The result of each translation unit is an object file. Then you link those two object files into the executable file.
Just got into C++ and I have a quick question.
After compiling with
g++ *.cpp -o output
I receive this error:
error: 'ostream' in 'class Dollar' does not name a type
These are my three files:
main.cpp
#include <iostream>
#include "Currency.h"
#include "Dollar.h"
using namespace std;
int main(void) {
Currency *cp = new Dollar;
// I want this to print "printed in Dollar in overloaded << operator"
cout << cp;
return 0;
}
Dollar.cpp
#include <iostream>
#include "Dollar.h"
using namespace std;
void Dollar::show() {
cout << "printed in Dollar";
}
ostream & operator << (ostream &out, const Dollar &d) {
out << "printed in Dollar in overloaded << operator";
}
Dollar.h
#include "Currency.h"
#ifndef DOLLAR_H
#define DOLLAR_H
class Dollar: public Currency {
public:
void show();
};
ostream & operator << (ostream &out, const Dollar &d);
#endif
Thank you for your time, and everything helps!
You have a number of errors in the code.
You heavily use using namespace std. This is a bad practice. In particular, this led to the error you faced: you don't have using namespace std in Dollar.h, thus the compiler has no idea what ostream means. Either put using namespace std in Dollar.h too, or better just stop using it and specify the std namespace directly, as in std::ostream.
You use std::ostream in your headers, but you don't include the corresponding standard library header <ostream> in them (<ostream> contains the definition of std::ostream class; for the full I/O library include <iostream>). A really good practice is to include all the dependencies of the header in the header itself, so that it is self-contained and can be safely included anywhere.
You are implementing a stream output operator with signature std::ostream & operator << (std::ostream &, Dollar const &), which is perfectly valid. However, you call it for a pointer to type Dollar. You should rather call it with the object itself, not the pointer, so you should dereference the pointer: std::cout << *cp;.
You implemented the output operator for the Dollar class, but use it for a variable of type Currency: this won't work. There is a way to do this - there do exist virtual methods for this exact reason. However, in this case the operator is a free function, thus it cannot be virtual. So, you should probably add a virtual print method to your Currency class, implement it in Dollar, and call it from output operator:
#include <iostream>
class Currency {
public:
virtual void print (std::ostream &) const = 0;
};
class Dollar : public Currency {
void print (std::ostream & out) const override {
out << "A dollar";
}
};
std::ostream & operator << (std::ostream & out, Currency const & c) {
c.print(out);
return out;
}
int main(/* void is redundant here */) {
Currency *cp = new Dollar;
std::cout << *cp;
// return 0 is redundant in main
}
You need to #include <iostream> within Dollar.h so that your std::ostream & operator is resolved by the compiler.
xml_attribute.h
#pragma once
#ifndef XML_ATTRIBUTET_H
#define XML_ATTRIBUTET_H
#include <string>
#include <iostream>
struct XML_AttributeT{
std::string tag;
std::string value;
//constructors
explicit XML_AttributeT(std::string const& tag, std::string const& value);
explicit XML_AttributeT(void);
//overloaded extraction operator
friend std::ostream& operator << (std::ostream &out, XML_AttributeT const& attribute);
};
#endif
xml_attribute.cpp
#include "xml_attribute.h"
//Constructors
XML_AttributeT::XML_AttributeT(std::string const& tag_, std::string const& value_)
: tag{tag_}
, value{value_}
{}
XML_AttributeT::XML_AttributeT(void){}
//overloaded extraction operator
std::ostream& operator << (std::ostream &out, XML_AttributeT const attribute){
return out << attribute.tag << "=" << attribute.value;
}
driver.cpp
#include <iostream>
#include <cstdlib>
#include "xml_attribute.h"
int main(){
using namespace std;
XML_AttributeT a();
cout << a << endl;
return EXIT_SUCCESS;
}
The output from the driver is a '1' but I want it to be an '=' sign.
Why is it outputting the reference to a?
If I change XML_AttributeT a(); to XML_AttributeT a; it doesn't even compile.
What did I do wrong?
chris is correct. Your initial issue is that XML_AttributeT a() is interpreted as a function declaration. clang++ will actually warn you of this:
Untitled.cpp:33:21: warning: empty parentheses interpreted as a function declaration [-Wvexing-parse]
XML_AttributeT a();
You can use a{} instead to fix this.
At this point you get a new error:
Untitled.cpp:34:10: error: use of overloaded operator '<<' is ambiguous (with operand types 'ostream' (aka 'basic_ostream<char>') and 'XML_AttributeT')
cout << a << endl;
This is because of what jogojapan said. Your implemented operator<< is using XML_AttributeT const as the attribute type instead of XML_AttributeT const &. If you fix that, then it compiles and gives you the result you want.
I'm having an issue with my operator<< overloading where I can not access the private variables of the class it is in no matter what I do because it will say that the variables are private as a compiler error. This is my current code:
#include "library.h"
#include "Book.h"
using namespace cs52;
Library::Library(){
myNumberOfBooksSeenSoFar=0;
}
//skipping most of the functions here for space
Library operator << ( ostream &out, const Library & l ){
int i=myNumberOfBooksSeenSoFar;
while(i<=0)
{
cout<< "Book ";
cout<<i;
cout<< "in library is:";
cout<< l.myBooks[i].getTitle();
cout<< ", ";
cout<< l.myBooks[i].getAuthor();
}
return (out);
}
And the function prototype and private variables in library.h are
#ifndef LIBRARY_H
#define LIBRARY_H
#define BookNotFound 1
#include "Book.h"
#include <iostream>
#include <cstdlib>
using namespace std;
namespace cs52{
class Library{
public:
Library();
void newBook( string title, string author );
void checkout( string title, string author ) {throw (BookNotFound);}
void returnBook( string title, string author ) {throw (BookNotFound);}
friend Library operator << ( Library& out, const Library & l );
private:
Book myBooks[ 20 ];
int myNumberOfBooksSeenSoFar;
};
}
#endif
Your << operator should have this protoype:
std::ostream& operator << ( std::ostream &out, const Library & l )
^^^^^^^^^^^^^
You need to return a reference to std::ostream object so that you can chain stream operations.
Also, If you declare it as friend in your Library class you should be able to access all the members(private/protected) of the Library class in your overloaded function.
As such i fail to understand your code, You declared your << operator as:
friend Library operator << ( Library& out, const Library & l );
^^^^^^^^^^^^
You defined your operator function with prototype:
Library operator << ( ostream &out, const Library & l )
^^^^^^^^^^^
They are different!
In short you never declared the function where you are accessing the private member as a friend of your class and Hence the error.
Also, the return type is Incorrect as I mentioned before.