从 C# 切换到 C++。我的代码有什么问题吗？我需要标题来完成我想要做的事情吗？一个文件中的类定义问题

Question

我用 C# 编程已有几年了，因为它是我的第一语言。我正在尝试温习我的 C++，因为我很快就会开发一些用 C++ 编码的东西。

这段代码有什么问题：（我知道可能有很多问题。C++ 与 C# 的需求有很大不同）。有人告诉我，我不知道如何在 C++ 中正确声明类，并且我需要使用标头来定义我的类。我需要标题吗？这是一个只是为了测试的小程序，想知道如果没有它是否可以完成。缺少的标头是这里唯一的问题吗？我遇到了无法访问 Company 中的 Parse 的错误，但是当我在 Company 类名前面添加 public 时，它会引发更多错误。

啊！太令人沮丧了。

#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

首先，您不需要用于测试目的的标头。但是没有它们你就无法编写真正的程序，因为标头定义了单独编译的程序部分的接口。这就是 C/C++ 的工作方式，没有办法绕过。

其次，您必须将 public: 添加到您的 Company 类中并处理以下错误。它就像 C# 的东西：您必须定义一个函数 public void Parse(string) 才能从类外部访问它。 C++ 方法是

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

第三种，在 C++ 中在类定义中定义非平凡函数是非常规的（唯一的例外是模板类）。这就是标题故事的另一面。

好的，这是与标头相关的基本内容的简要说明。

程序通常分为一组单独编译的文件，即翻译单元。每个单元通常由一个 .cpp 文件和一个或多个头文件 (.h) 组成。编译这些文件后，您将获得一个二进制 .obj 文件。该文件包含对象 - 初始化全局（和命名空间）对象所需的函数和内容的代码。要制作一个程序，您需要将一个或多个目标文件传递给链接器。在 VS 中，它发生在幕后。您只需将 .cpp 文件添加到项目树中，IDE 将相应地配置项目依赖项。

您的代码可能如下所示：

//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;
}

因此，基本上我们将拥有 employee、company 和 main 单位。 employee.h 中 Employee 类的定义包含重要的函数声明。像 GetSalary() 这样的简单函数就在类内部定义。它向编译器提示内联它。 employee.cpp 包含其余的函数定义；

company.h 文件具有 #include "employee.h" 预处理器语句。因此，我们可以在类定义及其实现文件 (company.cpp) 中使用 Employee 对象。

main.cpp 包含程序入口点。它能够使用 Company 类，因为它包含“company.h”。

如果我们更改 Employee::Hire() 函数实现中的某些内容，则只有 employee.obj 会被重新编译。这是这样的节目组织的主要目的。但是，如果我们更改 Employee 接口（employee.h 中的类定义），每个程序单元都需要重新编译。

如果您执行以下操作，则需要包含防护：

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

基于 Microsoft Visual C++ 的项目通常使用 #pragma Once 来达到相同目的。它更容易使用，但通常不便携。

例如，如果您将 Employee::Hire 定义放入 employee.h 中，编译器会将函数代码放入 employee.obj 和 company.obj 中（因为 company.h< /code> 包括 employee.h）。当您尝试在这种情况下链接时，链接器将遇到同一功能代码的 2 个版本，并会给出错误。内联函数不会编译成单独的实体，因此不会导致此类错误。模板代码也是如此，仅在实例化模板时生成。因此，多个翻译单元可能具有相同非内联模板函数的代码。

由程序员来定义程序的各部分边界。如果需要，您可以将公司和员工放入单个翻译单元中。 VS 向导倾向于为每个主要类创建一个 .h/.cpp 对。尝试做一个MFC项目，自己看看。

这些是基础知识。正如我在上面的评论中提到的，您可以从 Stroustrup 的《C++ 编程语言》中全面了解此类内容

Answer 2

您可以使用 public 来开始类中的公共方法部分，而不是类本身。也就是说，您应该在 Company 类中的 Parse 方法之前添加 public:。

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

public:
  void Parse(string input)
  {

Answer 3

这只是为了扩展帕维尔自您在评论中提出要求以来的第三点。

他的意思基本上是这样的：在任何真正的 C++ 项目中，您都需要将类的定义与其实现分离成两个文件，一个头文件 (*.h) 和实现文件( *.cpp）。使用上面的示例，它可以像这样分开：

// 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
}

并且您的 main.cpp 将像这样使用上面的内容：

// 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); 
}

现在来自 C# 背景的您可能想知道为什么事情是这样完成的 - 毕竟您最终得到了文件数量是原来的两倍！简短的答案是因为 C 就是这样做的，而 C++ 继承了 C 的很多包袱

。较长的答案是因为 C++ 不使用像 C# 和 Java 那样的“模块”系统。构建源文件时，编译器除了正在编译的当前文件之外不会查看其他任何地方。因此，编译器了解您正在使用的类、函数或变量是否存在的唯一方法是，它是否在使用之前出现在正在编译的源文件中的某个位置。由 #include 指令引入的所有标头以及源 .cpp 的正文就是所谓的“编译单元”——它是一个独立的单元，包含编译器的所有内容需要知道成功编译而不需要在其他地方寻找。