Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 6 years ago.
Improve this question
I would like to make this programm show the "Gianna" "Maria" and "M" strings on the screen but I can't. There's no error so I guess there's something wrong with my programm. Any suggestions what could fix my programm?
#include <iostream>
#include <string>
using namespace std;
class name
{
string fName, mName, sName;
public:
name (string fName, string mName, string sName){};
void setFName (string fName);
void setMName (string mName);
void setSName (string sName);
string getFName() const {return fName;}
string getSName() const {return sName;}
string getMName() const {return mName;}
friend ostream & operator <<(ostream &, const name &);
};
ostream& operator<<(ostream& os, const name& n) {
return os << n.fName << " " << n.sName<< " " << n.mName;
}
int main ()
{
name myName ("Gianna", "Maria", "M");
cout<<myName.getFName()<<" "<<myName.getMName()<<" "<<myName.getSName()<<endl;
return 0;
}
Your constructor:
name (string fName, string mName, string sName){};
doesn't do anything. You need to use the parameters to initialise your member variables.
name (string f, string m, string s)
: fName(f), mName(m), sName(s) {}
You forgot to initialize daya members of the class in the constructor.
Define the constructor the following way
name( const string &fName, const string &mName, const string &sName )
: fName( fName ), mName( mName ), sName( sName )
{
}
Correspondingly these member functions should be defined like
void setFName ( const string &fName)
{
this->fName = fName;
}
void setMName (const string &mName)
{
this->mName = mName;
}
void setSName (const string &sName)
{
this->sName = sName;
}
There is no need to make the operator << as a friend function of the class. It can be defined like
ostream& operator <<( ostream& os, const name& n ) {
return os << n.getFName() << " " << n.getMName() << " " << n.getSName();
}
Your constructor must assign the parameters you pass to the member variables, that doesn't happen automatically.
name (string fName, string mName, string sName) : fName(fName), mName(mName), sName(sName) {};
For your constructor, you have the three strings as your parameters but you aren't setting the member variables to their values. You can use an initializer list on the constructor like this...
name (string f, string m, string s)
: fName(f), mName(m), sName(s) // member(parameter) format
{
}
...or you can implement the setter stubs you have...
void setFName(string name) { this->fName = name;}
... and use them inside of your constructor like...
name (string fName, string mName, string sName) {
setFName(fName);
//...
}
Basically the parameters passed in the constructor are getting lost since you are not assigning it to the class vars..
Do something like:
name (string f, string m, string s) : fName(f), mName(m), sName(s){....};
try this. You forgot to implement Constructor of the class
#include <iostream>
#include <string.h>
using namespace std;
class name
{
string sFName, sMName, sSName;
public:
name (string FName, string MName, string SName);
void Display();
void setFName (string fName);
void setMName (string mName);
void setSName (string sName);
string getFName() const {return sFName;}
string getSName() const {return sSName;}
string getMName() const {return sMName;}
};
name::name(string FName, string MName, string SName )
{
sFName = FName;
sMName = MName;
sSName = SName;
}
void name::setFName(string fName)
{
sFName = fName;
}
void name::setMName(string mName)
{
sMName = mName;
}
void name::setSName(string sName)
{
sSName = sName;
}
void name::Display()
{
cout<< sFName<< endl;
cout<< sMName<< endl;
cout<< sSName<< endl;
}
int main ()
{
name myName ("Gianna", "Maria", "M");
myName.Display();
return 0;
}
Related
I have some problem with overloading += operator
I want to add a item to vector (getAuthorList) with += operator
How can I do it in main ?
Code snippet (header file) :
class Author {
public:
Author(std::string firstName, std::string lastname, std::string affiliation);
std::string getFirstName();
std::string getLastName();
std::string getAffiliation();
void setFirstName(std::string);
void setLastName(std::string);
void setAffiliation(std::string);
void printFullName();
friend std::ostream& operator<<(std::ostream& output, const Author& author);
private:
std::string firstName;
std::string lastname;
std::string affiliation;
};
class Publication {
public :
Publication(std::string tiltle, Date publishDate, std::string publisher);
vector<Author> getAuthorList();
Author& operator+=(Author);
private:
vector<Author> authorList;
};
You can overload += operator like this
void operator+=(Author);
Change the operator return type to void as you are storing it in Publication class so it does not make any sense to return The same author from this operator.
you can write the operator definition like this
void Publication::operator+=(Author auth){
this->authorList.push_back(auth);
}
here is the working example:
#include <string>
#include <vector>
#include <iostream>
class Author {
public:
Author(const std::string& name):
Name(name){
}
const std::string& getName() const{
return Name;
}
private:
std::string Name;
};
class Publication {
public :
Publication(){
}
void operator+=(Author);
void getAuthorList(){
for (const auto& author: authorList){
std::cout << author.getName() << std::endl;
}
}
private:
std::vector<Author> authorList;
};
void Publication::operator+=(Author auth){
this->authorList.push_back(auth);
}
int main(){
Publication pub;
Author auth("Alice");
pub += auth;
Author auth2("Mark");
pub += auth2;
pub.getAuthorList();
}
Note: I just tried to make simple.
You could use the std::vector method called push_back inside the implementation block of your overloaded operator.
I've done the Harvard CS50 Course and worked with python a fair bit. I'm now doing a C++ course (Microsoft's) and the learning exercise has me creating a few classes. The exercise specifically tasks me to instantiate a few objects in main and return some values;
#include <iostream>
#include "School.h"
int main()
{
Student student1("Joe", "Bloggs", 31, "123 Fake Street", "London");
Student student2("Fred", "Adams", 24, "95 Something Avenue", "Manchester");
Student student3("John", "Doe", 90, "44a Old Man Lane", "Kettering");
Course course1("Introduction to Psychology");
course1.addStudent(student1);
course1.addStudent(student2);
course1.addStudent(student3);
Teacher teacher1("Helen", "Professorson", 48, "15 Teacher Way", "Kent");
course1.addTeacher(teacher1);
std::cout << course1.getCourseName() << std::endl;
teacher1.GradeStudent();
}
I'm using a header file and cpp file to define the classes, School.h:
#pragma once
#include <string>
class Person
{
public:
// Constructors and Destructors
Person();
Person(std::string, std::string); // First and Last Name
Person(std::string, std::string, int, std::string, std::string, std::string); // fName, lName, Age, Address, City, Phone
~Person();
// Member functions
std::string getFirstName();
void setFirstName(std::string);
std::string getLastName();
void setLastName(std::string);
int getAge();
void setAge(int);
std::string getAddress();
void setAddress(std::string);
std::string getCity();
void setCity(std::string);
std::string getPhone();
void setPhone(std::string);
private:
std::string _fName;
std::string _lName;
int _age;
std::string _address;
std::string _city;
std::string _phone;
};
class Student : public Person
{
public:
// Constructors and Destructors
// Member Functions
void SitInClass();
};
class Teacher : public Person
{
public:
// Member Functions
void SitInClass();
void GradeStudent();
};
class Course
{
public:
// Constructors and Desctructors
Course();
Course(std::string); // course name
~Course();
// Member functions
void addStudent(Student);
void addTeacher(Teacher);
// Getters and Setters
std::string getCourseName();
void setCourseName(std::string);
private:
// Member variables
std::string _courseName;
Student _students[30];
Teacher _teacher;
};
School.cpp:
#include "School.h"
#include <iostream>
#include <string>
// Constructors
Person::Person()
{
std::string _fName{};
std::string _lName{};
int _age{};
std::string _address{};
std::string _city{};
std::string _phone{};
}
Person::Person(std::string fName, std::string lName)
{
std::string _fName{ fName };
std::string _lName{ lName };
int _age{};
std::string _address{};
std::string _city{};
std::string _phone{};
}
Person::Person(std::string fName, std::string lName, int age, std::string address, std::string city, std::string phone)
{
std::string _fName{ fName };
std::string _lName{ lName };
int _age{ age };
std::string _address{ address };
std::string _city{ city };
std::string _phone{ phone };
}
// Destructor
Person::~Person()
{
}
std::string Person::getFirstName()
{
return this->_fName;
}
void Person::setFirstName(std::string fName)
{
this->_fName = fName;
}
std::string Person::getLastName()
{
return this->_lName;
}
void Person::setLastName(std::string lName)
{
this->_lName = lName;
}
int Person::getAge()
{
return this->_age;
}
void Person::setAge(int age)
{
this->_age = age;
}
std::string Person::getAddress()
{
return this->_address;
}
void Person::setAddress(std::string address)
{
this->_address = address;
}
std::string Person::getCity()
{
return this->_city;
}
void Person::setCity(std::string city)
{
this->_city = city;
}
std::string Person::getPhone()
{
return this->_phone;
}
void Person::setPhone(std::string phone)
{
this->_phone = phone;
}
void Student::SitInClass()
{
std::cout << "Sitting in main theater" << std::endl;
}
void Teacher::SitInClass()
{
std::cout << "Sitting at front of class" << std::endl;
}
void Teacher::GradeStudent()
{
std::cout << "Student Graded" << std::endl;
}
Course::Course()
{
Student* _students;
Teacher* _teacher;
std::string _name{};
}
Course::Course(std::string name)
{
Student* _students[30];
Teacher* _teacher;
std::string _name{ name };
}
Course::~Course()
{
}
void Course::addStudent(Student student)
{
// TODO: Loop through _students and insert new student in
}
void Course::addTeacher(Teacher teacher)
{
this->_teacher = &teacher;
}
std::string Course::getCourseName()
{
return this->_name;
}
void Course::setCourseName(std::string name)
{
this->_name = name;
}
I actually haven't been taught inheritance yet, but since both Student and Teacher needed the same variables (name, age, address etc.) I decided it'd be sensible.
Having a few problems though:
My instantiations of Student and Teacher in main.cpp aren't correct. I think because they are inheriting from Person(?). How do I create a constructor within these derived classes? I googled this but the solutions didn't seem to work.
The Course Class requires an array of Students. Do I have to specify a size of the array in the header file? It seems silly that I've specified 30 in both the header file and the cpp file, but VSstudio complains if I don't.
I'm using strings here. I have previously learned from a different course about char* and memory regarding strings. How many chars are assigned to all of these string class variables? If I instantiate a Students with name "Joe" and then want to later change his name to "Joseph" using student1.SetFirstName, is that going to cause segmentation faults?
Thanks, I figured it out mostly...
I needed to create constructors in Student and Teacher with the same input variables as the Person class, and then call the Person constructor in the Student consturctor:
Student::Student()
{
}
Student::Student(std::string fName, std::string lName)
: Person(fName, lName)
{
}
Student::Student(std::string fName, std::string lName, int age, std::string address, std::string city, std::string phone)
: Person(fName, lName, age, address, city, phone)
{
}
You do not need to specify array size in the constructor:
Header file looks like this:
class Course
{
...
private:
// Member variables
std::string _name;
Student* _students[30];
Teacher* _teacher;
};
And the constructor looks like this:
Course::Course()
: _students{ 0 }, _teacher{ 0 }, _name{}
{
}
To initialise every array item to 0.
Not so sure on still...
What would I use to define these Variables outside the Public and Private? Enum?
The Instructions for this section are this:
A default constructor. Remember that the default constructor for Address has the following initial values: Address to "99999 Sunset Boulevard" , "Beverly Hills", "CA", "99999"
4 private string instance variables for :Street, City, State, Zip
A constructor with 4 parameters: one for street, one for city, one for state, one for zip.
A printAddress(): it prints the Street, City, State, and Zip
Here is what I got so far
class Address
{
public:
Address();
Address(City defaultCity, State defaultState, Street defaultStreet, Zip, defaultZip);
int getCity();
int getState();
int getStreet();
int getZip();
int printAddress();
private:
int Street, City, State, Zip;
};
Address :: Address(City defaultCity, State defaultState, Street defaultStreet, Zip, defaultZip);
{
defaultCity = City
defaultState = State
defaultStreet = Street
defaultZip = Zip
}
Address::Address()
{
Street = "99999 Sunset Boulevard,";
City = "Beverly Hills,";
State = "CA,";
Zip = "99999";
}
int Address::getCity()
{
return City;
}
int Address::getState()
{
return State;
}
int Address::getStreet()
{
return Street;
}
int Address::getZip()
{
return Zip;
}
int Address::printAddress()
{
return Street, City, State, Zip;
};
Also when he says "print" I assume he means display right?
Thank you
I would do it like this:
#include <iostream>
#include <string>
/********************
* File: Main.cpp *
********************/
/*
* For simplicity I put it all in one file.
*/
class Address
{
public:
explicit Address();
explicit Address(const std::string& city, const std::string& state,
const std::string& street, const std::string& zip);
const std::string& getCity() const;
const std::string& getState() const;
const std::string& getStreet() const;
const std::string& getZip() const;
void printAddress() const;
private:
std::string street;
std::string city;
std::string state;
std::string zip;
};
// Default Constructor
Address::Address() :
city("Beverly Hills"),
state("CA"),
street("99999 Sunset Boulevard"),
zip("99999")
{ }
Address::Address(const std::string& city, const std::string& state,
const std::string& street, const std::string& zip) :
city(city), state(state), street(street), zip(zip)
{ }
const std::string& Address::getCity() const
{
return city;
}
const std::string& Address::getState() const
{
return state;
}
const std::string& Address::getStreet() const
{
return street;
}
const std::string& Address::getZip() const
{
return zip;
}
void Address::printAddress() const
{
std::cout << street << ", " << city << ", "
<< state << ", " << zip << std::endl;
};
int main(int argc, char* argv[]) {
Address defaultAddress;
defaultAddress.printAddress();
Address customAddress("Cologne", "NRW", "Domplatz 1", "D-50668");
customAddress.printAddress();
return 0;
}
EDIT:
Explaining some changes.
Look at the private section of the class declaration. You declared members as int although they should be strings. I corrected that.
In the constructors you should use initialization lists to initialize members.
In your constructor parameter list you used the words City, State, Street and Zip as if they were types. Which they are not. The type of these parameters is std::string. Or in my case I chose const std::string& because I prefer passing by reference over passing by value if both are viable.
If methods do not change the object you may declare them const so they can be called also on const instances of the class or const references. I did so in this example when declaring the getters.
I did not see a need to return anything to the caller after printing so I changed the return type to void.
I added a main function to test the class.
There is probably a lot more to say about the differences, but I think this is enough for tonight.
Cheers!
This question already has answers here:
C++: Initialization of inherited field
(5 answers)
Closed 5 years ago.
This post was edited and submitted for review 12 months ago and failed to reopen the post:
Original close reason(s) were not resolved
I want to create a base class with two set, and derived class (inherit) with one set method. I want to combine them in a parameterized constructor.
#include <iostream>
#include <string.h>
using namespace std;
class Code
{
protected:
string letter;
int number;
public:
string getletter();
int getnumber();
void setletter(string letter1);
void setnumber(int number1);
};
void Code::setletter(string letter1)
{
letter=letter1;
}
void Code::setnumber(int number1)
{
number=number1;
}
string Code::getletter()
{
return letter;
}
int Code::getnumber()
{
return number;
}
class Course : public Code
{
private:
string name;
public:
Course(string name1, string letter1, int number1);
string getname();
void show();
};
Course::Course (string name1, string letter1,int number1) :
setletter(letter1), setnumber(number1) //Parameterized Constructor
{
name=name1;
letter=letter1;
number=number1;
}
string Course::getname()
{
return name;
}
void show()
{
Course com("Testing","TST",101);
cout<<"Constructor >>>\n Course Name : "<< com.getname()<<"\n Course Code : "<< com.getletter() << com.getnumber()<<endl;
}
int main()
{
show();
}
If it matters, I am using Microsoft's Visual C++.
You can call them inside your constructor
Course::Course (const string& name1, const string& letter1, const int number1) :
{
name=name;
setletter(letter1); // equivalent to letter=letter1
setnumber(number1);
}
You can add a constructor to your Code class
Code(const string& letter, const int number);
And call it like that in your Course constructor
Course::Course(const string& name1, const string& letter1, const int number1)
: Code(letter1, number1), name(name1)
{
}
But I'm not sure of what your asking, if you can be a little more precise on what you want that could be great, thanks.
The : after the parameter list of a constructor is the 'member initializer list'.
Course::Course (string name1, string letter1,int number1)
: name(name1), letter(letter1), number(number1) { }
I am trying to do a polymorphism in C++ language. My parent class is Person then there is a derived class called Student. Here is my Person.h and .cpp:
class Person
{
public:
Person(string name);
virtual void display() const;
string get_name() const;
void set_name(string name);
string get_birthDay() const;
void set_birthDay(string birthDay);
private:
string name;
string birthDay;
};
.cpp:
Person::Person(string name)
{
this->name = name;
}
string Person::get_name() const
{
return name;
}
void Person::set_name(string name)
{
this->name = name;
}
string Person::get_birthDay() const
{
return birthDay;
}
void Person::set_birthDay(string birthDay)
{
this->birthDay = birthDay;
}
void Person::display() const
{
cout << get_name() << " " << get_birthDay() << endl;
}
And this is my Student.h and .cpp:
class Student : public Person
{
public:
Student(string name, string major);
virtual void display() const;
string get_major() const;
void set_major(string major);
private:
string major;
};
.cpp:
Student::Student(string name, string major)
:Person(name)
{
this->major = major;
}
string Student::get_major() const
{
return major;
}
void Student::set_major(string major)
{
this->major = major;
}
void Student::display() const
{
cout << get_name() << " " << get_major() << endl;
}
All working perfectly until my main method. Here is my main method:
int main()
{
vector <Person*> person_list;
person_list.push_back(Student("Student","IT"));
person_list.push_back(Instructor("Instrructor", 2500));
for(int count=0; count< person_list.size(); count++)
{
cout << person_list[count]->display() << endl;
}
system("Pause");
return 0;
}
I got an error at the push_back and cout there. The error message for push_back to vector is: no instance of overloaded function matches the argument list. As for the cout, no operator matches the operands. I have no idea why. Anybody can help me fix it?
Thanks in advance.
Your person_list stores pointer but you pushed object instead:
To fix your issue:
person_list.push_back(new Student("Student","IT"));
//^^^^
person_list.push_back(new Instructor("Instrructor", 2500));
To store pointer in STL container, better use smart pointer:
#include <memory>
std::vector <std::unique_ptr<Person>> person_list;
You will need to push back a pointer to Student; i.e. use
person_list.push_back(new Student("Student","IT")); etc.
But, you will need to be very very careful with memory, since you will need to delete the memory you've allocated; the vector will not do this for you when it destructs.
Consider using a smart pointer instead.
cout << person_list[count]->display() << endl;
The display() function is of void return type. You cannot output that.
As for the push_back: like the others said, if you've got a vector of pointers, you need to push_back a pointer, not the object.