0

我正在编写一个程序来使用插入排序对办公室员工的向量进行排序。我在插入员工记录时面临疑问。疑点是：-

  1. 在评论#1 中，为什么我使用指向 cOffice 类的指针向量？为什么我不能只使用简单对象的向量？
  2. 在评论#2 中，为什么我使用new关键字在运行时创建内存？为什么我不能像将对象复制到其他对象一样复制一个类实例（连同参数）？

代码和注释如下：-

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class cPerson
{
    private:
    string firstname,lastname;
    int age;
    public:
    cPerson(string fn,string ln,int a)      // constructor to input the firstname, lastname and age of the person
    {
        firstname=fn;
        lastname=ln;
        age=a;
    }
    void displaycPerson()
    {
        cout<<"First Name = "<<firstname<<"\n";
        cout<<"Last Name = "<<lastname<<"\n";
        cout<<"Age = "<<age<<"\n";
    }
    string getLastName()
    {
        return lastname;
    }
};
class cOffice
{
    private:
        vector<cPerson*> v;         // Comment#1 and the alteranate code is: vector<cPerson> v;
        int nElem;                      
    public:
        cOffice(int max)
        {
            v.resize(max);              
            nElem=0;                    
        }
        ~cOffice()
        {
            for(int i=0;i<nElem;i++)    // no use of the destructor if the above code is implemented
                delete v[i];
        }
        void insertRec(string fn1, string ln1, int a1)      // inserting the record
        {
            v[nElem] = new cPerson(fn1,ln1,a1);     // Comment#2 and the alteranate code is: v[nElem] = cPerson(fn1,ln1,a1);
            nElem++;
        }
        void InsertionSort()
        {
            int compare,pivot;
            for(pivot=1;pivot<nElem;pivot++)
            {
                cPerson* temp = v[pivot];       
                compare=pivot;
                while(compare>0&&v[compare-1]->getLastName()>=temp->getLastName())
                {   
                    v[compare]=v[compare-1];
                    compare--;
                }
                v[compare] = temp;
            }
        }   
        void display()
        {
            for(int i=0;i<nElem;i++)
                v[i]->displaycPerson();
        }
};
int main(void)
{
    cOffice obj(10);
    obj.insertRec("Evans", "Patty", 24); 
    obj.insertRec("Adams", "Henry", 63);
    obj.insertRec("Yee", "Tom", 43);
    obj.insertRec("Smith", "Lorraine", 37);
    obj.insertRec("Hashimoto", "Sato", 21);             
    obj.insertRec("Stimson", "Henry", 29);
    obj.insertRec("Velasquez", "Jose", 72);
    obj.insertRec("Lamarque", "Henry", 54);
    obj.insertRec("Vang", "Minh", 22);
    obj.insertRec("Creswell", "Lucinda", 18);
    obj.display();
    obj.InsertionSort();
    obj.display();
    return 0;
}

显然，其余代码将通过替换->和.删除所有取消引用操作符进行相应更改*。

如果我进行了问题中提到的所有编辑，程序会显示错误，如下所示：

In member function 'void std::vector<_Tp, _Alloc>::resize(std::vector<_Tp, Alloc>::size_type, std::vector<_Tp, _Alloc>::value_type) [with _Tp = cPerson; _Alloc = std::allocator<cPerson>; std::vector<_Tp, _Alloc>::size_type = unsigned int; std::vector<_Tp, _Alloc>::value_type = cPerson]':
   exp.cpp:40:16: error: no matching function for call to 'cPerson::cPerson()'
   exp.cpp:40:16: note: candidates are:
   exp.cpp:11:2: note: cPerson::cPerson(std::string, std::string, int)
   exp.cpp:11:2: note:   candidate expects 3 arguments, 0 provided
   exp.cpp:5:7: note: cPerson::cPerson(const cPerson&)
   exp.cpp:5:7: note:   candidate expects 1 argument, 0 provided
4

3 回答 3

2

正如在回答和评论中提到@xgbi的，在只有少数对象的情况下，应该首选对象向量。如果复制对象非常昂贵并且您有很多对象，则应该使用指针。

vector<cPerson>您的代码不起作用的原因是您创建了大小为 10 的向量。这告诉编译器创建 10 个类型的对象cPerson，但没有任何参数。所以编译器尝试调用cPerson();. 此构造函数不存在，您提供的唯一一个是两个字符串和一个 int。

以这种方式更改您的代码

cOffice(int max)
{
    v.reserve(max); // not strictly necessary, but may improve performance      
}

void insertRec(string fn1, string ln1, int a1)
{
    v.push_back(cPerson(fn1,ln1,a1));
}

而不是nElem你应该使用v.size().

于 2013-06-27T07:35:10.093 回答
1

我认为您需要正确建模继承的指针。在办公室中，会有不同的人，对他们建模的自然方法是使用基类 cPerson，由 - 例如 - cEmployee 继承，然后由 - cManager 等继承。这种建模依赖于虚拟函数来获取访问权限到常见的建模属性。

C++ 需要指针（或引用）才能使用虚函数调用。因此需要指针。

于 2013-06-27T07:33:18.930 回答
0

在对数组进行排序时，我认为操作指针会比操作对象实例更快。
在实例的情况下，您的InsertionSort()函数将调用大量的复制构造函数（这意味着：2 个新字符串分配、2 个 memcpy 和 2 个旧字符串上的空闲内存）。在指针的情况下，它只是交换值。

所以IMO你可以使用堆实例。

现在，使用指针进行排序的好处只对几千个条目很重要。在您的情况下，有 10 个条目，增益并不那么重要。因此，请随意切换到存储对象。这将使您的代码更小，更重要的是，更易于维护。

另外，另一个原因可能是您没有 cPerson 的复制构造函数，并且希望保持这种方式（请参阅Rule of Three）

于 2013-06-27T07:09:29.397 回答