Class creation not working

[neverStopLearning]

I am required to create a Class named Employee which has 3 separate constructors.
1 takes in 5 arguments and assigns attributes to the appropriate data members
1 takes in 2 arguments and assigns attributes to the appropriate data members, and the other 3 are initialized directly to blanks if strings or 0 if int.
1 takes in 0 arguments and initializes all data members to blanks if strings or 0 if int.

I am receiving a flurry of errors from my header file that says, "missing type sepcifier- int assumed"
I am also receiving a flurry of errors from my implementation file that says my variables are "undeclared identifier"
Does anyone have an idea as to why this is occurring? I do not see any errors in my structure or logic.

//employee.cpp
#include"employee.h"
#include<iostream>

using namespace std;


Employee::Employee()
{
	name = idNumber = department = position = " ";
	yearsWorked = 0;
}

Employee::Employee(string person, string iD)
{

	name = person;
	idNumber = iD;
	department = "";
	position = "";
	yearsWorked = 0;
}

Employee::Employee(string person, string iD, string dep, string pos, int yrs)
{
	name = person;
	idNumber = iD;
	department = dep;
	position = pos;
	yearsWorked = yrs;
}

void Employee::setName(string person)
{
	name = person;

}
void Employee::setidNumber(string iD)
{
	idNumber = iD;
}
void Employee::setDepartment(string dep)
{
	department = dep;
}
void Employee::setPosition(string pos)
{
	position = pos;
}
void Employee::setYrsWorked(int yrs)
{
	if(yrs < 0)
		yearsWorked = 0;
	else
		yearsWorked = yrs;
}

string Employee::getName()
{
	return name;
}
string Employee::getidNumber()
{
	return idNumber;
}
string Employee::getDepartment()
{
	return department;
}
string Employee::getPosition()
{
	return position;
}
int Employee::getYrsWorked()
{
	return yearsWorked;
}

//employee.h

#include<iostream>
#include<iomanip>
#include<string>



/*
---------------------------------------------------

				
				Employee DataBase

----------------------------------------------------
-name:string
-idNumber:string
-department:string
-position:string
-yearsWorked:integer 
----------------------------------------------------
+Employee()
+Employee(person:string, iD:string, dep:string, pos:string, yrs:int)
+Employee(person:string, iD:string)
+getName(person:string):void;
+getidNumber():void;
+getDepartment():void;
+getPosition():void;
+getYrsWorked():void;
+setName():string;
+setidNumber():string;
+setPosition():string;
+setYrsWorks():integer;

*/


class Employee
{
private:
	string name;
	string department;
	string position;
	string idNumber;
	int yearsWorked;

public:
	Employee();
	Employee(string person, string iD, string dep, string pos, int yrs);
	Employee(string person,string iD);
	void setName(string person);
	void setidNumber(string iD);
	void setPosition(string pos);
	void setDepartment(string dep);
	void setYrsWorked(int yrs);
	string getName();
	string getidNumber();
	string getDepartment();
	string getPosition();
	int getYrsWorked();

};

//main

#include"employee.h"
#include<iostream>

using namespace std;



int main()
{
	Employee person1("Jenny Jacobs", "JJ8990", "Accounting", "President", 15);
	Employee person2("Myron Smith", "MS7571");
	Employee person3();
	cout << "Name" << setw(8) << " " << "| ID Number" << setw(8) << " " << "| Department" << setw(8) << " " << "| Position" << setw(8) << " " << "| Years Worked" << setw(8) << " ";
	
	cout << endl;

	system("pause");
	return 0;
}

[edge6768]

You are missing the scope resolution in the employee.h file for std::string, so it is not registering as a type. Put using std::string; in the global space of the file and these should resolve. Let me know if it doesn't :)

[neverStopLearning]

That did fix it, but shouldn't the #include<string> that I have in my .h file solve this issue?

[edge6768]

No, that just tells the preprocessor to use the 'string' definition file within the source code. The actual definitions are nested within namespaces like so:

namespace std {
    class string {
        /* class definition, functions, etc... */
    }
}

The purpose of the namespace is to 'hide' what is inside of it with an extra identifier, the scope resolution (ie: std::string in this case). This is useful with large projects where 50 people are all writing their own code to avoid collisions with common identifiers like x, dX, or whatever. It's kind of like how each person has a first name and a last name. Usually, the first name is enough to determine who is being referred to in a local context, but people tend to name their children from a small subset of names, so occasionally a last name is needed to determine who is being referred to.

Reference: http://www.cplusplus.com/doc/oldtutorial/namespaces/

It's also worth noting that in your employee.h file you #include <iostream> and then you include it again in the employee.cpp file. This is unnecessary because your employee.cpp file also includes employee.h, which has #include <iostream> already.


As one final sidenote, it's good practice to avoid using namespace std; in larger projects as the std namespace has a HUGE amount of identifiers that can inadvertently cause collisions with your identifiers. Instead, you might want to use the using std::<identifier> for each thing you want to grab from that namespace (like using std::string;, using std::cout;, and using std::cin;) That being said, if you're just tinkering around this is probably not necessary, but it is good to keep in mind.

[neverStopLearning]

I see. I have always just used #include<string> and it was never a problem. But maybe it is different when building classes?

About your other 2 comments, I know I am being redundant in the #include<iostream> by having it in both the .h and .cpp file, but my professor requires us to do it this way.

Also with the using namespace std our professor requires us to do it this way. I began my previous programs by using the using std:: and he explained how this was the old way of doing things and it is not the correct way to do it anymore.

All of the forums and tutorials I read explain to use the using std:: <identifier> and once I do not have to deal with this professor anymore I will begin to do it in this way.

Thank you for your help!

[Naughty Albatross]

Glad it helped :)

[edge6768]

As far as I know you always need some kind of scope resolution, be it using namespace std; or using std::string;, but it may depend on what you're compiling with (that's a bit out of my league >,<).

Professors are weird. I had one that was teaching us c++ but didn't let us use anything except cin and cout from the std library...

Anywhos, best of luck!