예제 #1
0
int main(){
    Group g;
    g.add(Student("aaa","aaa"));
    g.add(Student("bbb","bbb"));
    g.add(Student("ccc","ccc"));
    g.showAll();
    return 0;
}
예제 #2
0
/*******************************************************************************************************************************************************
Function Name:		EditStudent()
Purpose:			take firstname and lastname of the student from the user to edit if the student is found edit the student else give a message 
					student not found
In Parameters:		None
out parameters:		NONE
Version:			4
Author:				Lovejot Singh	
********************************************************************************************************************************************************/
bool DBManager::EditStudent(){

	char fName[25];
	char lName[20];
	cout<<"Edit Student"<<endl;
	cout<<"Please enter the first name of the student to edit (e.g. Barack)";		
	cin>>fName;
	cout<<"Please enter the last name of the student to edit (e.g. Barack)";
	cin>>lName;
	Student stud= Student(fName,lName,"",-1);			//creating a temp object of Student class to use == operator
	bool found=false;										// found bool to check if the student was found


	for(int loop=0;loop<max;loop++){						// for loop to check if the name given by the user was found in the database
		if(Students[loop].GetID() != -1)
		if((stud == Students[loop])){				//using overlaoded eqaulsto operator
			found= true;
			cout<<"Student Found  with name ";
			cout<<fName <<" "<< lName << endl;
			cout<<"Editing Name: ";
			cout << fName<<" "<<lName<<endl;		
			Students[loop].EditStudent();						//calling edit function related to the student object
			break;
		}
	}
	if(!found){					//if the name was not found in the database let the user know 
		cout<<"Student not Found !\n";
		return true;
	}
	
	return true;
}
예제 #3
0
파일: main.cpp 프로젝트: exuuwen/study
void main()
{ 
	Student  CR7("CR7");
	cout<<Student::nums()<<endl;
	
	Student   s1;

	Student  s2=Student("messi");
}
예제 #4
0
void test1(){
  Professor();
  int i;
  for(i=0;i<1;i++) {
    Student(i, 3);    
  } 
  while (1);
  
}
예제 #5
0
void test3(){
  Professor();
  int i;
  for(i=0;i<10;i++) {
    Student(i, 25);       
  } 
  while (1);

}
예제 #6
0
int main()
{
	set<int, greater<int>> setA;//默认是set<T,less<T>>升序
	setA.insert(11);
	setA.insert(22);
	setA.insert(33);
	setA.insert(22);
	setA.insert(44);
	setA.insert(55);
	setA.insert(22);
	setA.insert(3);
	for (set<int,greater<int>>::iterator it = setA.begin(); it != setA.end(); ++it)
		cout << *it << " ";

	cout << endl << "*******************" << endl;
	setA.erase(22);
	for (set<int, greater<int>>::iterator it = setA.begin(); it != setA.end(); ++it)
		cout << *it << " ";

	set<int>::iterator itF = setA.find(11);//find()
	int nFind = *itF;

	int iCount = setA.count(3);//count()

	//lower_bound(),upper_bound()
	set<int>::iterator itLower = setA.lower_bound(3);
	set<int>::iterator itUpper = setA.upper_bound(11);

	//pair
	pair<set<int>::iterator, set<int>::iterator> itPair = setA.equal_range(33);
	set<int>::iterator itFirst = itPair.first;
	set<int>::iterator itSecond = itPair.second;

	cout << endl << "*******************" << endl;
	set<Student, stuFunctor> stuA;
	stuA.insert(Student(3, "小明"));
	stuA.insert(Student(5, "小刚"));
	stuA.insert(Student(4, "小草"));
	stuA.insert(Student(1, "小花"));
	stuA.insert(Student(2, "小晶"));
	for (set<Student, stuFunctor>::iterator it = stuA.begin(); it != stuA.end(); ++it)
		cout << "ID: " <<it->ID<<"\t姓名: "<<it->Name<< endl;
	return 0;
}
void Classroom::Clear()
{
    for (IndexType col = 1; col < col_ - 1; col++)
        for (IndexType row = 1; row < row_ - 1; row++)
        {
            students_[row][col] = Student();
        }
    ModifySide();
    is_clean_ = true;
}
예제 #8
0
Student StudentLinkedList::Retrieve(const Student &key)
{
    Node *curr = mHead;
    while (curr) {
        if (curr->mData == key) {
            return curr->mData;
        } else {
            curr = curr->mNext;
        }
    }
    return Student();
}
예제 #9
0
void test5(){
  Professor();
  int i;
  for(i=0;i<100;i++) {
	int bloop = random()%5+2;
    Student(i, bloop);
	//printf("The number of questions for student %d is %d\n", i, bloop);
    usleep(random()%1000);   
  }
  while (1);

}
예제 #10
0
void test4(){
  Professor();
  int i,j;
  for(j=0;j<5;j++) {
    for(i=0;i<2;i++) {
     
      Student(i+j*2, random()%10+1);  

    } 
    sleep(50);  
  }
  while (1);
 
}
예제 #11
0
QList<Student> LoginManager::SearchStudents(QString keyword)
{
    if(db.open())
    {
        QList<Student> list;
        QString queryString = QString("SELECT * FROM students WHERE RollNo LIKE '%").append(keyword).append("%'");
        QSqlQuery query = db.exec(queryString);
        while(query.next())
        {
            list.append(Student(query.value(0).toString(), query.value(1).toString(), query.value(2).toString(), query.value(3).toString(), query.value(4).toString(), query.value(7).toInt()));
        }

        db.close();
        return list;
    }
}
예제 #12
0
int main(int argc, char *argv[])
{
	
	totalStudents = atoi(argv[1]);
	inOffice = atoi(argv[2]);
	int i;
	
	Professor();
	
	for(i = 0 ; i < totalStudents; i++)
	{
		Student(i);	
	}
	
	pthread_exit(NULL);
}
예제 #13
0
void addStudent(Student st[], int &nrOfStudents){
    string name;
    string program;
    int phoneNumber;
    int dateOfBirth;
    cout << "Enter name: ";
    getline(cin,name);
    cout << "Enter program: ";
    getline(cin,program);
    cout << "Enter phone number: ";
    cin >> phoneNumber;
    cout << "Enter date of birth: ";
    cin >> dateOfBirth;
    st[nrOfStudents] = Student(name, program, phoneNumber, dateOfBirth);
    nrOfStudents++;

}
예제 #14
0
/*******************************************************************************************************************************************************
Function Name:		DeleteStudent()
Purpose:			delete a student
In Parameters:		None
out parameters:		NONE
Version:			1
Author:				Lovejot Singh	
********************************************************************************************************************************************************/
bool DBManager::DeleteStudent(){
	int id ;													//temporary int to store user input
	bool found=false;											// to check if user enter id was matched
	cout<<"Please enter the id of the student to delete ";		
	cin>>id;													
	for(int loop=0; loop <max ;loop++){							//for loop to find student of the id enter by user
		if(Students[loop].GetID()==id){
				Students[loop]=Student("","","",-1);		// change id to -1 set it out of scope
			
			found=true;
				cout<<"Student Deleted !\n"<<endl;
				return true;
		}
	}
	if(!found){cout<<"Student not found ! Please try again with correct ID !\n";}		//if the id didn't match let the user Know
	return true;
}
void Classroom::ModifySide()
{
    students_[0][0] = Student({RIGHT, DOWN});           // upper left
    students_[0][col_ - 1] = Student({LEFT, DOWN});      // upper right
    students_[row_ - 1][0] = Student({UP, RIGHT});       // lower left
    students_[row_ - 1][col_ - 1] = Student({LEFT, UP});  // lower right

    for (IndexType col = 1; col < col_ - 1; col++)
    {
        students_[0][col] = Student({LEFT, DOWN, RIGHT});      // upside
        students_[row_ - 1][col] = Student({LEFT, UP, RIGHT});  // below
    }

    for (IndexType row = 1; row < row_ - 1; row++)
    {
        students_[row][0] = Student({UP, RIGHT, DOWN});       // left side
        students_[row][col_ - 1] = Student({UP, LEFT, DOWN});  // right side
    }
}
예제 #16
0
int main(int argc, char* argv[])
{
  Student cheolsu(550001, "철수", "근처", 97);
  Student younghee(550002, "영희", "먼곳", 100);
 
  std::vector<Student> stu_list;
  stu_list.push_back( cheolsu);
  stu_list.push_back( younghee);
  stu_list.push_back( Student(550003, "만수","어중간한 곳", 87));


  for( std::vector<Student>::const_iterator it = stu_list.begin() ; it != stu_list.end() ; ++it) {
    std::cout<<"Name : "<< it->getName() << " Address : "<<it->getAddress()<<" Score : "<<it->getScore()<<std::endl;
    
  } 


  return 0;
}
예제 #17
0
/******************************************************************************************************************************************************
Function Name:		ReportStudentsOrdered()
Purpose:			Prints the students in alphabetic order of their last name
In Parameters:		None
out parameters:		NONE
Version:			1
Author:				Lovejot Singh	
********************************************************************************************************************************************************/
bool DBManager::ReportStudentsOrdered(){
	bool notempty=false;
	Student temp= Student();
	int studs=0; // total number of students in the database
	for(int loop=0;loop<max;loop++){
		if(Students[loop].GetID()!=-1){
			studs=loop;				//maximum number of studs in database
			notempty=true; // the database in not emtpy
		}
	}
	if(notempty){		// the database is not empty
		bool swap=false;			// swap boolean to keep track of swaping taking place in buble sort
		Student buble[max+1];			// temp buble array to hold student for buble sorting
		for(int loop =0;loop<=studs;loop++){		//for loop to copy array
			buble[loop]=Students[loop];				//assigning array by index
		}

		while(swap!=true){							//while the array is not swaped

				swap=true;							//set boolean value to true
			for(int loop=0;loop<studs;loop++){
			//buble sort algorithm
				if(buble[loop+1].GetID() !=-1)
				if(buble[loop] > buble[loop+1] ){

					temp=buble[loop+1];
					buble[loop+1]=buble[loop];
					buble[loop]=temp;
					swap=false;						//swap occured turn boolean to false and let the loop run once again
			}
		}
	}
		//printing students order by last name
		for(int loop=0;loop<=studs;loop++){
			if(buble[loop].GetID()!=-1)
			cout<<buble[loop];
		}
	}
	else {
		cout<<"Database is empty ! "<<endl;
	}
	return true;
}
예제 #18
0
int main(int argc, char **argv) {
    std::string name;
    vector<Student> students;
    int sum = 0;
    for (int i = 1; i < argc; ++i) {
        istream in(argv[i]);
        while (in >> name) {
            int mark;
            students.push_back(Student(name, argv[i]));
            auto it = students.end() - 1;
            in >> mark;
            while (mark != 0) {
                it->marks.push_back(mark);
                it->sum += mark;
            }
            sum += (double)it->sum / it->marks.size();
        }
    }
}
예제 #19
0
void InsertStudent::go()
{
    string ID = getStuIDFromInput();
    if(!db.doInsertStudent(Student(ID)))
    {
        cout << "Student already exist" << endl << endl;
        return;
    }

    string name = getStuNameFromInput();
    unsigned int year = getStuYearFromInput();
    char gender = getStuGenderFromInput();

    if(db.doModifyStudent(ID, name, year, gender))
        cout << "Creation of student record successful" << endl << endl;
    else
        db.doDeleteStudent(ID);

    return;
}
예제 #20
0
/*******************************************************************************************************************************************************
Function Name:		AddNewStudent()
Purpose:			takes firstname , lastname , comment and fee from the user and add the student to the first available index of the array with id one 
					greater than of a student before. For the first student it gives an id of 0 .
In Parameters:		None
out parameters:		return true
Version:			3
Author:				Lovejot Singh	
********************************************************************************************************************************************************/
bool DBManager::AddNewStudent(){

	int index,
		loop,
		tempID=-1;	//index used to find first available ,loop  used in for loop , tempID is used to find the highest id of the array
	float fee=0;				// fee used to take user input		
	char fName[25];				// temporary array of chars to hold firtname
	char lName[25];				//temporary array of chars to hold lastname
	char tcomment[1000];		//temporary array of chars to hold comment
	bool labhgea=false;			// labhgea is used to check if there is an empty slot in an array or not	

	for(loop=0;loop<max;loop++){			//for loop to find the available index to add new student
		if(Students[loop].GetID()==-1 && !labhgea ){	// && !labhgea is used to make sure we add student at first available space in the array
		labhgea=true;						//space found go true
		index=loop;							// index found 
		}	
	}
	tempID=-1;					
	for(int mas=0;mas<max;++mas){			//for loop to find the highest ID of the array 
		if(tempID < Students[mas].GetID()){ 
			tempID=Students[mas].GetID();
		}
	}
	++tempID;								//increase the id 
	if(labhgea == false){					// if no empty slot available 
		cout<<"Database is already full !!"<<endl;
		return true;
	}

	// take inputs from the user 
	cout<<"Please enter the new student first name (e.g. Barrack): ";
	cin>>fName;
	cout<<"Please enter the new student last name (e.g. Obama): ";
	cin>>lName;
	cout<<"Please enter the comment ( 1000 characters max ): ";
	cin.ignore();
	cin.getline(tcomment,sizeof(tcomment));

	Students[index]=Student(fName,lName,tcomment,tempID);		//using overloaded assignment operator to assign the value 
	return true;
}
void InputHandler::parseFile() {
	// Declare string to analyze
	string line;

	// First line is the number of windows open
	getline(f, line);
	int totWindows = atoi(line.c_str());
	GenQueue<Arrival> *genQueue = new GenQueue<Arrival>();

	while (getline(f, line)) {
		// Second line is a clock tick
		int clockTick = atoi(line.c_str());

		// Third line is how many students arrive
		getline(f, line);
		int numStuds = atoi(line.c_str());

		// Following lines are how many minutes a student needs at the window
		Student *studArray;
		studArray = new Student[numStuds];
		for (int i=0; i<numStuds; ++i) {
			getline(f, line);
			int minsNeeded = atoi(line.c_str());
			studArray[i] = Student(minsNeeded);
			studAmt++;
		}

		// Create Arrival object
		Arrival *arrival = new Arrival(clockTick, numStuds, studArray);

		// Put arrival into queue
		genQueue->enqueue(arrival);
	}
	// Create Registrar object for statistics calculations
	registrar = new Registrar(totWindows, genQueue);
}
/**
 * Helper method that deals with each line of the file load in.
 *
 * @param input
 * the input file.
 * @return
 * A vector of Student objects to be inserted to the linked list.
 */
vector<Student> fileInputAndOutput::getLineFromFile(ifstream& input) {
	vector<string> stringVector;

	vector<Student> studentVector;
	string line;

	while (getline(input, line)) {

		char delimiter = ',';

		stringVector = this->split(line, delimiter);

		int grade = atof(stringVector[3].c_str());

		stringVector[0] = this->stringToLower(stringVector[0]);
		stringVector[1] = this->stringToLower(stringVector[1]);

		Student currentStudent = Student(stringVector[0], stringVector[1],
				stringVector[2], grade, 0, 0);

		studentVector.push_back(currentStudent);
	}
	return studentVector;
}
예제 #23
0
int main(){
	srand(time(0));

	int facultyCount = rand() % 2000 + 1000;	//average 2500 faculty
	int studentCount = facultyCount * 5 + rand() % 1000 - rand() % 1000;	//average 12.5k students
	int organizationCount = studentCount / 25 + rand() % 200 - rand() % 200;//average 500 organizations
	int courseCount = facultyCount / 5;			//average 500 courses offered

	cout<<facultyCount<<"  Faculty\n"<<studentCount<<"  Students \n"<<organizationCount<<"  Groups\n"<<courseCount<<"  Courses\n";

	//create our base objects for the university
	cout<<"Hiring Faculty..."<<endl;
	for(int i = 0; i < facultyCount; i++){
		faculty.push_back(Faculty());
	}
	cout<<"Accepting Student Applications..."<<endl;
	for(int i = 0; i < studentCount; i++){
		students.push_back(Student());
	}
	cout<<"Founding Organizations..."<<endl;
	for(int i = 0; i < organizationCount; i++){
		organizations.push_back(Organization());
	}
	cout<<"Designing Curriculum..."<<endl;
	unordered_set<string> uniqueCourses;	//the set stores only unique values and determines duplicates in O(1) time.  This is how we keep from regenerating the same class twice
	for(int i = 0; i < courseCount; i++){

		Class newClass;
		string key;
		do{
			newClass = Class();	//regenerate a class if it already exists
			key = newClass.subject + itos(newClass.number);
		}while(uniqueCourses.find(key) != uniqueCourses.end());	//loop until we fail to find a course with this key value.  then we'll know it's unique

		uniqueCourses.insert(uniqueCourses.begin(), key);
		courses.push_back(newClass);
	}

	//create relations between these base objects (a.k.a the hard part).
	cout<<"Opening Registration & Open House..."<<endl;
	for(int i = 0; i < studentCount; i++){
		for(int j = 0; j < (rand() % 20)+1; j++){//average 10 enrollments over the course of 4 semesters
			enrollment.push_back(EnrolledIn(students[i]));
		}

		for(int j = 0; j < rand() % 4; j++){	//up to 3 memberships per student
			membership.push_back(MemberOf(students[i]));
		}
	}
	cout<<"Assigning Professors..."<<endl;
	for(int i = 0; i < facultyCount; i++){
		for(int j = 0; j < rand() % 4; j++){	//faculty can teach up to 3 courses
			instruction.push_back(Teaches(faculty[i]));
		}		
	}
	cout<<"Volunteering Faculty to Organizations..."<<endl;
	for(int i = 0; i < organizationCount; i++){
		if(rand() % 5 == 0) leadership.push_back(Leads());	//a quarter of organizations have faculty leadership
	}

	cout<<"Checking constraints..."<<endl;

	for(int i = 0; i < courseCount; i++){
		if(courses[i].size == 0){
			cout<<"Empty course fixed\n";
			enrollment.push_back(EnrolledIn(&courses[i]));
		}
		if(!courses[i].hasProf){
			cout<<"Untaught course fixed\n";
			instruction.push_back(Teaches(&courses[i]));
		}
	}
	for(int i = 0; i < organizationCount; i++){
		if(organizations[i].size == 0){
			cout<<"Empty organization fixed\n";
			membership.push_back(MemberOf(&organizations[i]));
		}
	}

	cout<<"Writing data to file...\n"<<endl;	//self explanatory vvvvvv
	openFile();

	for(int i = 0; i < facultyCount; i++){
		writeFaculty(faculty[i].ID, faculty[i].name, faculty[i].salary);
	}
	for(int i = 0; i < studentCount; i++){
		writeStudent(students[i].UIN, students[i].name, students[i].major, students[i].advisorID);
	}
	for(int i = 0; i < organizationCount; i++){
		writeStudentOrganization(organizations[i].ID, organizations[i].name, organizations[i].category);
	}
	for(int i = 0; i < courseCount; i++){
		writeCourse(courses[i].subject, courses[i].number, courses[i].hours, courses[i].title);
	}
	for(int i = 0; i < enrollment.size(); i++){
		writeEnrolledIn(itosem(enrollment[i].semester), enrollment[i].subject, enrollment[i].number, enrollment[i].UIN, itograde(enrollment[i].grade));
	}
	for(int i = 0; i < instruction.size(); i++){
		writeTeaches(instruction[i].subject, instruction[i].number, instruction[i].facultyID, itosem(instruction[i].semester));
	}
	for(int i = 0; i < leadership.size(); i++){
		writeLeads(leadership[i].facultyID ,leadership[i].studentOrgID, itos(leadership[i].joinedMo)+"/"+itos(leadership[i].joinedYr));
	}
	for(int i = 0; i < membership.size(); i++){
		writeMemberOf(membership[i].UIN, membership[i].studentOrgID, itos(membership[i].joinedMo)+"/"+itos(membership[i].joinedYr));
	}
	
	closeFile();
	cout<<"All data generated"<<endl;
}
예제 #24
0
#include "Student.h"

Student std1 = Student("201424546", "AA", "g", 14, 85);
Student std2 = Student("201424547", "AB", "ge", 14, 85);
Student std3 = Student("201424548", "AC", "ge", 14, 85);
Student std4 = Student("201424549", "AD", "gey", 14, 85);
Student std5 = Student("201424550", "AE", "geyo", 14, 85);
Student std6 = Student("201424551", "AF", "geyon", 14, 85);
Student std7 = Student("201424552", "AG", "geyong", 14, 85);
Student std8 = Student("201424553", "AH", "geyongn", 14, 85);
Student std9 = Student("201424554", "AI", "geyongna", 14, 85);
Student std10 = Student("201424555", "AJ", "geyongnam", 14, 85);
Student std11 = Student("201424556", "AK", "geyongnama", 14, 85);
Student std12 = Student("201424557", "AL", "geyongnamaa", 14, 85);
Student std13 = Student("201424558", "AM", "geyongnamaaa", 14, 85);
Student std14 = Student("201424559", "AN", "geyongnamaaaa", 14, 85);
Student std15 = Student("201424560", "AO", "geyongnamaaaaa", 14, 85);
Student std16 = Student("201424561", "AP", "geyongnamas", 14, 85);
Student std17 = Student("201424562", "AQ", "geyongnamasd", 14, 85);
Student std18 = Student("201424563", "AR", "geyongnamasdf", 14, 85);
Student std19 = Student("201424564", "AS", "geyongnamb", 14, 85);
Student std20 = Student("201424565", "AT", "geyongnambb", 14, 85);
Student std21 = Student("201424566", "AU", "geyongnambbb", 14, 85);
Student std22 = Student("201424567", "AV", "geyongnambbbb", 14, 85);
Student std23 = Student("201424568", "AW", "geyongnambbbbb", 14, 85);
Student std24 = Student("201424569", "AX", "geyongnamc", 14, 85);
Student std25 = Student("201424570", "AY", "geyongnamcc", 14, 85);
Student std26 = Student("201424571", "AZ", "geyongnamccc", 14, 85);
Student std27 = Student("201424572", "BA", "geyongnamcccc", 14, 85);
Student std28 = Student("201424573", "BB", "geyongnamccccc", 14, 85);
Student std29 = Student("201424574", "BC", "geyongnamccc", 14, 85);
예제 #25
0
//this function takes the command from the cmd into commands that the program knows
void ParseCommand(Command cmd, std::vector<std::string> payload)
{
	if (cmd == Invalid)
	{
		printMessage("Invalid command.");
	}

	//adds a student
	else if (cmd == Add)
	{
		//Add a student
		if (payload.size() != 6)
		{
			//bad news throw the user an error.
			printMessage("Command add recieved incorrect # of arguments.");
		}
		else
		{
			//constuct the student
			Student toAdd = Student(payload[0], payload[1], payload[2],
				std::stoi(payload[3]), std::stoi(payload[4]), std::stoi(payload[5]));

			//make sure that id dosent exsist
			std::vector<Student> toCheck = students.searchStudents(students.ID, toAdd.getUID());

			//if to check == 0 then student doesnt exsist
			if (toCheck.size() < 100)
			{
				//make sure the student is valid
				if (!toAdd.isValidStudent())
				{
					printMessage("Invalid student attribute.");
					return;
				}

				//add
				students.addStudent(toAdd);
				students.saveStudent();
				std::cout << toAdd.getName() + " successfully added" << std::endl;
			}
			else
			{
				std::cout << "Student already exists" << std::endl;
			}
		}
	}

	//remove a student
	else if (cmd == Remove)
	{
		//see if student exsists
		std::vector<Student> toCheck = students.searchStudents(students.ID, payload[0]);

		//see if student exsist
		if (toCheck.size() != 0)
		{
			std::cout << "Student does not exist." << std::endl;
		}
		else
		{
			//delete student
			students.deleteStudent(toCheck[0]);
			students.saveStudent();
			std::cout << "Student deleted successfully" << std::endl;
		}
	}

	//search for student
	else if (cmd == Search)
	{
		//make sure there are arguments 
		if (payload.size() == 0)
		{
			std::cout << "Printing all students:" << std::endl;
			students.printAllStudents();
			return;
		}
		else
		{
			//slit the payload
			std::vector<std::string> commands = fileIO::split(payload[0], '=');

			//make sure the format  is correct
			if (commands.size() < 2)
			{
				printMessage("Search argument recieved invalid. Format should be [email protected].");
			}
			else
			{
				Students queryList = Students(students.searchStudents(commands[0],commands[1]));

				//iterate through rest of the arguments
				for (int i = 1; i < payload.size(); i++)
				{
					std::vector<std::string> commands = fileIO::split(payload[i], '=');

					if (commands.size() != 2)
					{
						printMessage("Search argument recieved invalid. Format should be [email protected].");
					}

					queryList = queryList.searchStudents(commands[0], commands[1]);
				}
			
				queryList.printAllStudents();
			}
		}
	}

	//update the student
	else if (cmd == Update)
	{
		//search for the student
		std::vector<Student> tempStudents = students.searchStudents(Students::ID, payload[0]);
		
		//for each argument update that one
		for (int i = 1; i < payload.size(); i++)
		{
			std::vector<std::string> commands = fileIO::split(payload[i], '=');
			students.updateInfo(tempStudents[0], commands);
		}

		students.saveStudent();
	}
	//you need help so print it
	else if (cmd == Help)
	{
		std::cout << "Here are a list of all the example commands: " << std::endl;
		std::cout << "add <name>,<UID>,<email>,<firstscore>,<secondscore>,<thirdscore>" << std::endl;
		std::cout << "remove <UID>" << std::endl;
		std::cout << "search UID=<id>,name=<bob>" << std::endl;
		std::cout << "update <UID>,UID=<id>,name=<new name>" << std::endl;
	}
}