指针的克隆载体

Question

你好，我是新来的，也是 C++ 的新手。我有一个问题，我需要制作我的指针向量的备份副本。但我无法正确理解它。我在这个论坛上找到了我的案例的解决方案，但无法正确解决：

class cloneFunctor {
public:
    T* operator() (T* a) {
        return a->clone();
    }
}

我试图将其实现到我的代码中，但无法得到很好的解决方案，有人可以帮助我解决这个问题吗？

我的代码：

sever.cpp

  #include "server.h"
    #include <iostream>
    #include <functional>
    #include <algorithm>
    #include <iterator>
    class Client;


    class cloneFunctor {
    public:
        cloneFunctor* operator() (cloneFunctor* a) {
            return a->clone();
        }
    };

    Server *Server::instance = 0;

    Server& Server::getInstance() {
        if (instance == 0)
            instance = new Server();
        return (*instance);
    }

    void Server::setStatus(bool status) {
        this->nStatus = status;
        changeClientStatus();
        writeStateToConsole();
    }

    bool Server::getStatus() {
        return nStatus;
    }

    void Server::writeStateToConsole() {
        std::cout << "Server state: " << getStatus() << std::endl;
    }

    void Server::subscribeToServer(Client &temp) {
        listOfClients.push_back(&temp);
    }
    void Server::writeClients() {
        for (unsigned int i = 0; i < listOfClients.size(); i++) {
            std::cout << i+1  << ". client status: " << listOfClients[i]->getStatus() << std::endl;
        }
    }

    void Server::changeClientStatus() {
        if (nStatus == 0){
            makeCopy(listOfClients);
            for (unsigned int i = 0; i < listOfClients.size(); i++) {
                listOfClients[i]->setStatus(false);
            }
        }
        else
            restoreCopy();

    }

    void Server::makeCopy(std::vector<Client *>listOfClients) {
         transform(listOfClients.begin(), listOfClients.end(), back_inserter(listOfClientsOld), cloneFunctor());
    }
    void Server::restoreCopy() {


    }

server.h

#ifndef SERVER_H_
#define SERVER_H_

#include "abstractbaseclass.h"
#include "server.h"
#include "client.h"



class Client;
class Server : public Abstractbaseclass {
    friend class Client;
public:
    static Server& getInstance();
    virtual void setStatus(bool status);
    virtual bool getStatus();
    virtual void writeStateToConsole();
    void subscribeToServer(Client &temp);
    void writeClients();
    void changeClientStatus();
    void makeCopy(std::vector<Client *>listOfClients);
    void restoreCopy();


 private:
    static Server *instance;
    Server(){};
    std::vector <Client *>listOfClients;
    std:: vector <Client *> listOfClientsOld;
};


#endif /* SERVER_H_ */

程序应创建单例服务器 class，然后创建 3 个将订阅服务器的客户端（它们保存在指针向量中）。当我将服务器状态设置为 0 时，所有客户端都将其状态更改为关闭（bool false），并且在这之前应该创建备份向量，因为当我再次打开服务器时，客户端需要切换到关闭服务器之前的状态。

Answer 1

好的，所以他正在尝试教授某种基于事务的思维。

Client 可能需要赋值运算符

Client & operator=(Client & toCopy)
{
    // copy all of toCopy's members over to this
}

如果它还没有，并且包含您不能相信会自行复制的指针或复杂数据类型。

现在你可以轻松

clientA = clientB;

将clientB复制到clientA

然后我们进入主要事件 Server::restoreCopy()，它是以下内容的简单变体：

if (listOfClients.size() != listOfClientsOld.size())
{
    // back up is stale. Probably throw exception
}
for (size_t index = 0; index < listOfClients.size(); index++)
{
    *listOfClients[index] = *listOfClientsOld[index];
}

这些是 vector 的指针，因此您必须取消引用 (*) 指针以获得指向 Client 的指针，或者复制指针而不是指向的指针。请记住，Client 的克隆是一个完全不同的 Client，而不是 Server 的用户首先传入的内容。如果 Server 用户仍然持有最初的 Client 并使用它，如果您只复制指针，就会发生错误的 ju-ju。双方将在不同的 Client 上运行，即使它们看起来可能相同。只要修改一次，他们就不会

您也可以使用 std::transform 技巧在此处进行备份，但这简单明了且易于调试。也可以随意使用迭代器和基于范围的 for。

当你这样做的时候，祈祷自从你备份后没有人重新订购 listOfClients。

重要的旁注：

void makeCopy(std::vector<Client *>listOfClients);

很奇怪。它允许 Server 用户传入他们自己的 vector 并添加到任何现有备份。这包括 Server 本身。它不会删除任何现有备份，因此 listOfClientsOld 将继续增长。因为任何有权访问 Server 的人都可以调用它并传入他们自己的 vector，他们可以在备份中塞满荒谬的废话。我建议 makeCopy 不带任何参数，并从备份中删除任何现有的 Clients，并 delete 它们。更好的是，listOfClientsOld 根本不需要存储指针，而且可能也不应该。

很多指针在起作用，没有 deletes。必须有人归还您正在分配的所有内存，否则您最终会运行出局。

指针的克隆载体

Cloning vector of pointers

c++

clone

vector