从C＃切换到C ++。 我的代码出了什么问题？ 我需要标题我正在尝试做什么？ 一个文件问题中的类定义

Question

I've been programming in C# for a few years now, as it was my first language. I'm trying to brush up on my c++ because I will be working on something soon that is coded in that.

What is wrong with this code: (I know there might be a lot of things wrong. C++ is so different than C# in what it needs). Someone told me that I don't know how to declare classes correctly in C++, and that I need to define my classes using headers. Do I NEED headers? This is a small program just to test and would like to know if this can be accomplished without it. And are the missing headers the only issue here? I had a error about not being able to access Parse in Company, but when I add public in front of Company class name, it throws more errors.

AUGH! So frustrating.

#include "std_lib_facilities.h"
using namespace std;

class Employee
{
public:
    string screen_name;
    string real_name;
    string current_job;
    int employee_number;
    Employee(int no, string name1, string name2, string current_jobin)
    {
        screen_name=name1;
        real_name=name2;
        employee_number=no;
    current_job=current_jobin;
    }
};

class Project
{
public:
    Vector<Employee> Employees;
    int max_worker_quota;
    int project_id;
    string project_name;
    Project(int no_in,int max_in,string title_in)
    {
        max_worker_quota=max_in;
        project_name=title_in;
        project_id=no_in;
    }
};

unsigned int split(const std::string &txt, vector<std::string> &strs, char ch)
{
    unsigned int pos = txt.find( ch );
    unsigned int initialPos = 0;
    strs.clear();

    // Decompose statement
    while( pos != std::string::npos ) {
        strs.push_back( txt.substr( initialPos, pos - initialPos + 1 ) );
        initialPos = pos + 1;

        pos = txt.find( ch, initialPos );
    }

    // Add the last one
    strs.push_back( txt.substr( initialPos, std::min( pos, txt.size() ) - initialPos + 1));

    return strs.size();
}

class Company
{
Vector<Employee> Employeelist;
Vector<Project> Projectlist;

    void Parse(string input)
    {
        //Case Statements
        vector<string> temp;
        split( input, temp, ' ' );

        if (temp[0]=="S")
        {
            //Add Employee to Company
            Employee myEmployee=Employee(atoi(temp[1].c_str()),temp[2],temp[3],temp[4]);
            Employeelist.push_back(myEmployee);
        }
        else if (temp[0]=="C")
        {
            //Add Project to Company
            Project myProject=Project(atoi(temp[1].c_str()),atoi(temp[2].c_str()),temp[3]);
            Projectlist.push_back(myProject);
        }
        else if (temp[0]=="L")
        {
            //Add Employee to Project list
            //Not Implemented-Find Project by temp[1] which is a int
        }
        else if (temp[0]=="A")
        {
        }
        else if (temp[0]=="D")
        {
        }
        else if (temp[0]=="PS")
        {
        }
        else if (temp[0]=="PC")
        {
        }
    }
};

int main(int argc, char *argv[])
{
string input;
cout<<"Command:: ";
cin>>input;
Company myCompany;
myCompany.Parse(input); //Input is in the format X Name Name etc etc. Arguments separated by spaces

return 0;
}

Answer 1

First of all, you don't need headers for test purposes. But you can not make a real program without them, because the headers define the interface of separately compiled program parts. That's the way the C/C++ work, no way around.

Second, you have to add public: to your Company class and deal with the following errors. It is just like the C# stuff: you have to make a function defined public void Parse(string) to be able to access it from outside the class. The C++ way is

class Foo { 
public:
void Bar();
}; 

Third, it is unconventional in C++ to define non-trivial functions inside class definition (the only exception being template classes). That's the other side of the headers story tho.

OK, here is a brief explanation of basic header-related stuff.

Program is usually divided into the set of separately compiled files, that is to say translation units. Each unit usually consist of one .cpp file and one or more header files ( .h ). When these files are compiled you are getting a single binary .obj file. This file contains objects - the code for your functions and stuff needed to initialize global (and namespace) objects. To make a program you need to pass one or more object files to linker. In VS it happens behind the scene. You just add a .cpp file to your project tree and IDE will configure the project dependencies accordingly.

This is how your code may look like:

//File: employee.h

#ifndef EMPLOYEE_HDR  /* include guard */
#define EMPLOYEE_HDR

#include <string>

using std::string;

class Employee {
public:
Employee (int no, string name1, string name2, string current_jobin);

void PayBonus(int amount);

void Fire(string reason);

int GetSalary() const
{ return m_Salary; }

/*...*/
protected:
int m_Salary;
string m_FirstName;
/* ... */
};

#endif

//File: employee.cpp
#include "employee.h"

Employee::Employee (int no, string name1, string name2, string current_jobin)
{
 //definition
}

void Employee::PayBonus(int amount)
{
 //definition
}

void Employee::Fire(string reason)
{
//definition
}

/* define other non-trivial class functions here */

//File: company.h

#ifndef COMPANY_HDR  /* include guard */
#define COMPANY_HDR

#include <vector>
using std::vector;

#include "employee.h"

class Company {
public:
Company();
void Hire(string name);

void WorldCreditCrunch() //life is unfair
{ FireEveryone(); }

void Xmas(); //pays $5 bonus to everyone

/* ... */

protected:

vector<Employee> m_Staff;

void FireEveryone();

/* ... */
};

#endif

//File: company.cpp

#include "company.h"

Company::Company()
{
 //definition
}

void Company::Hire(string name)
{
     //calculate new employee ID etc
     m_Staff.push_back(Employe( /*...*/));
}

void Company::FireEveryone()
{
    for(size_t i = 0; i < m_Staff.size(); ++i)
         m_Staff[i].Fire();

}

void Company::Xmas()
{
    for(size_t i = 0; i < m_Staff.size(); ++i)
         m_Staff[i].PayBonus(5);
}

/* ... */

//File: main.cpp

#include "company.h"

int main()
{
     Company c;

     c.Hire("John Smith");

     /* ...*/

     return 0;
}

So, basically we gonna have employee , company and main units. The definition of Employee class in employee.h contains non-trivial functions declaration. A simple function like GetSalary() is defined right inside the class. It gives a hint to the compiler to inline it. The employee.cpp contains the rest of function definitions;

The company.h file has #include "employee.h" preprocessor statement. So we may use Employee objects in the class definition and in its implementation file ( company.cpp ).

The main.cpp contains the program entry point. It is able to use Company class cause it includes "company.h".

If we change something in the Employee::Hire() function implementation, only employee.obj will be recompiled. This is the main purpose of such program organization. But if we change the Employee interface (class definition in employee.h ) every program unit will require recompilation.

Include guards are needed in case you do something like this:

#include "employee.h"
#include "company.h"  /* will contain the 2nd inclusion of employee.h which will be 
                        prevented by include guard */

Projects based on Microsoft Visual C++ often use #pragma once for the same purpose. It is easier to use but generally not portable.

If you put, for example, Employee::Hire definition in the employee.h the compiler will put the function code in both employee.obj and company.obj (cause the company.h includes employee.h ). When you try to link in such situation the linker will encounter 2 versions of the same function code and will give an error. Inline functions are not compiled in into separate entities and thus don't cause such error. Same goes about template code which is generated only when the template is instantiated. So, several translation units may have code for the same non-inline template functions.

It is up to programmer to define the parts boundaries of the program. You may put Company and Employee into single translation unit, if you want. The VS wizards tend to make a .h/ .cpp pair for each major class tho. Try to make an MFC project and see for yourself.

These are the basics. As I mentioned in the comment above, you can get a full picture of such stuff from Stroustrup's "The C++ programming language"

Answer 2

You use public to begin a section of public methods within the class, not on the class itself. That is, you should add public: before the Parse method within the Company class.

class Company
{
  Vector<Employee> Employeelist;
  Vector<Project> Projectlist;

public:
  void Parse(string input)
  {

Answer 3

This is just to expand on Pavel's third point since you requested in your comment.

What he means is basically this: in any real C++ project you'll want to separate out the definition of your class from its implementation into two files, a header file ( *.h ) and implementation file( *.cpp ). Using your above example, it could be separated out like this:

// Employee.h
#ifndef EMPLOYEE_H
#define EMPLOYEE_H
#include <string>

class Employee
{
public:
    Employee(int no, 
             std::string name1, 
             std::string name2, 
             std::string current_jobin);

private:
    std::string screen_name;
    std::string real_name;
    std::string current_job;
    int employee_number;    
};
#endif

---

// Employee.cpp
#include "Employee.h"

Employee::Employee(int no, 
                   std::string name1, 
                   std::string name2, 
                   std::string current_jobin)
{
    screen_name = name1;
    real_name = name2;
    employee_number = no;
    current_job = current_jobin;
}

---

// Company.h
#ifndef COMPANY_H
#define COMPANY_H
#include <vector>
#include <string>
#include "Employee.h"
#include "Project.h"

class Company
{
public:
    void Parse(std::string input);

private:
    std::vector<Employee> Employeelist;
    std::vector<Project>  Projectlist;
};
#endif

---

// Company.cpp
#include "Company.h"

void Company::Parse(std::string input)
{
    // your code for Parse in Company goes here
}

and your main.cpp would use the above like this:

// main.cpp
#include <iostream>
#include <string>
#include "Company.h"

int main(int argc, char *argv[])
{
    std::string input;
    std::cout << "Command:: ";
    std::cin >> input;
    Company myCompany;
    //Input is in the format X Name Name etc etc. Arguments separated by spaces    
    myCompany.Parse(input); 
}

Now coming from a C# background you're probably wondering why things are done this way -- after all you end up with twice as many files! The short answer is because C did it this way and C++ inherited a lot of baggage from C.

The longer answer is because C++ doesn't use a 'module' system like what you'd find in C# and Java. When building a source file the compiler doesn't look anywhere else except for the current file it's compiling. So the only way the compiler will know about the existence of a class, function or variable that you're using is if it shows up somewhere in the source file being compiled prior to use. The inclusion of all the headers pulled in by the #include directive together with the body of the source .cpp is what's termed as a 'compilation unit' -- it's a self-contained unit containing everything the compiler needs to know to successfully compile without looking else where.