C++，运行时错误：对空指针类型的成员调用

Question

首先，我是 C++ 新手，我正在努力学习它。也是stackoverflow的新手。 很难说实话。 如果您对我的代码以及如何改进它有更多的 cmets，请告诉我，因为我仍在学习过程中。

好吧，我只是使用面向对象编程创建了一个在线预订系统。

好的，主要问题是我不明白为什么 system.setDisplay(1234); 没有打印任何东西。我已经尝试了一切，只是没有加起来。 OnlineBookingSystem 是用于调用 setDisplay(id) 的类，然后调用显示类。 如果你能提供帮助，这对我来说意味着世界，我得到的错误是：

运行时错误：对“用户”类型的空指针的成员调用 (solution.cpp) 摘要：UndefinedBehaviorSanitizer：undefined-behavior prog_joined.cpp:179:54

#include <vector>
#include <string>
#include <iostream>
#include <memory>
#include <queue>
using namespace std;

enum class BookGenre
{
    Horror,Adventure,Romance,Comic
};
class Book
{
    private:
        BookGenre genre;
        string title;
        size_t id;
    public:
        Book(string title,size_t id,BookGenre genre):title(title),id(id),genre(genre){}
        string getTitle(){return title;}
        size_t getId(){return id;}
        BookGenre getGenre(){return genre; }
};
class Library
{
    private:
        vector<shared_ptr<Book>> listOfBooks;
    public:
        Library(){};
        void addBook(string title,size_t id,BookGenre genre)
        {
            listOfBooks.push_back(make_shared<Book>(title,id,genre));
        }
        shared_ptr<Book> getBook(size_t id)
        {
            for(auto&x:listOfBooks)
            {
                if(x->getId()==id)
                {
                    return x;
                }
            }
            return nullptr;
        }
        void removeBook(size_t id)
        {
            for(auto it=listOfBooks.begin();it!=listOfBooks.end();it++)
            {
                if((*it)->getId()==id)
                {
                    listOfBooks.erase(it);
                }
            }
        }
};
class User
{
    protected:
        size_t id;
        string username;
     
    public:
        User(size_t id,string username):id(id),username(username)
        {
 
        }
        virtual ~User(){}
        size_t getId(){return id;}
        string getUsername(){return username;}

};
class Employee:public User{
    private:
        double salary;
    public:
        Employee(size_t id,string username,double salary):User(id,username),salary(salary)
        {
        }
        void setSalary(double salary)
        {
            this->salary=salary;
        }
        double getSalary(){return salary;}
     
};
class Customer:public User{
    private:
           bool membership;
    public:
        Customer(size_t id,string username):User(id,username)
        {
            membership=false;
        }
        void setMemberActive()
        {
            membership=true;
        }
        bool isMemberActive()
        {
            return membership;
        }
};
class UserManager
{
    private:
        vector<shared_ptr<User>>listOfUsers;
        queue<shared_ptr<Customer>>queue;
    public:
        UserManager()
        {

        }
      
        void addCustomer(size_t id,string username)
        {
            listOfUsers.push_back(make_shared<Customer>(id,username));
        }
        void removeCustomer(string username)
        {
            for(auto it=listOfUsers.begin();it!=listOfUsers.end();it++)
            {
                if(dynamic_pointer_cast<Customer>(*it))
                {
                    if((*it)->getUsername()==username)
                    {
                        listOfUsers.erase(it);
                    }
                }
            }
        }
        shared_ptr<Customer> getCustomer(string username)
        {
            for(auto it=listOfUsers.begin();it!=listOfUsers.end();it++)
            {
                if(dynamic_pointer_cast<Customer>(*it))
                {
                    if((*it)->getUsername()==username)
                    {
                        return dynamic_pointer_cast<Customer>(*it);
                    }
                }
            }
            return nullptr;
        }
        void addToQueue(string username)
        {
            queue.push(getCustomer(username));
        }
        void removeCurrentCustomer()
        {
            queue.pop();
        }
        shared_ptr<Customer> getNextCustomer()
        {
            if(queue.empty())
            {
                return nullptr;
            }
            return queue.front();
        }
        /*
            same process for user;
        */
};
class Display
{   
    private:
        shared_ptr<Customer> m_customer;
        shared_ptr<Book> m_book;
    public:
        Display(shared_ptr<Customer> _customer,shared_ptr<Book> _book ):m_customer(_customer),m_book(_book)
        {

        }
        shared_ptr<Customer> getUser(){return m_customer;}
        shared_ptr<Book> getBook(){return m_book;}
        void displayInfo()
        {
            cout<<"Customer username: "<<m_customer->getUsername()<<endl;
            cout<<"Member Active: "<<m_customer->isMemberActive();
            cout<<"book id: "<<m_book->getId()<<endl;
            cout<<"book title: "<< m_book->getTitle()<<endl;
        }

};
class OnlineBookingSystem
{
    private:
        UserManager manager;
        Library library;
        shared_ptr<Display>display;
    public:
        OnlineBookingSystem()
        {
            UserManager manager;
            Library library;
            this->manager=manager;
            this->library=library;
            this->display=nullptr;
        }
        Library getLibrary()
        {
            return library;
        }
        UserManager getUserManager()
        {
            return manager;
        }
        void  setDisplay(size_t id)
        {
            display=make_shared<Display>( manager.getNextCustomer(),library.getBook(id));
            display->displayInfo();
        }
        shared_ptr<Display> getDisplay()
        {
            return this->display;
        }
};
int main()
{

    OnlineBookingSystem system;
    auto lib=system.getLibrary();
    lib.addBook("Adventure of Pablo",1234,BookGenre::Adventure);
    auto manager=system.getUserManager();
    manager.addCustomer(2020,"Michael");
    auto _customer=  manager.getCustomer("Michael");
    _customer->setMemberActive();
    manager.addToQueue("Michael");
    system.setDisplay(1234);

    return 0;
}

Answer 1

我看到的问题：

问题 1

由于OnlineBookingSystem::getLibrary()的返回类型是Library，所以该行

auto lib=system.getLibrary();

将lib 构造为system 中对象的副本。对lib 所做的任何更改都是对副本的更改，而不是对system 中的Library 对象的更改。

要解决问题，请将返回类型更改为引用：

Library& getLibrary()
{
    return library;
}

并捕获返回值作为main 中的引用。

auto& lib=system.getLibrary();

问题 2

与问题 1 类似，但这次是在OnlineBookingSystem::getUserManager。将其返回类型更改为引用：

UserManager& getUserManager()
{
    return manager;
}

并捕获返回值作为main中的引用。

auto& manager=system.getUserManager();

问题 3

在每一步都采用防御性编程，直到出现性能瓶颈。如果函数的返回值可以是nullptr，则在调用时检查返回值，当返回值确实是nullptr时处理。

将OnlineBookingSystem::setDisplay 更新为：

    void  setDisplay(size_t id)
    {
        display=make_shared<Display>( manager.getNextCustomer(),library.getBook(id));
        if ( display )
        {
            display->displayInfo();
        }
        else
        {
           // Deal with the nullptr case
           std::cout << "Unable to find a book with id " << id << std::endl;
        }
    }

Answer 2

问题
这归结为您对system.getUserManager() 的调用返回了OnlineBookingSystem 的manager 字段的副本，而不是指向它的指针。

因此，当您调用manager.addToQueue("Michael") 时，它会将Michael 添加到int main() 本地的UserManager 实例，而不是system 中保存的实例。

您的函数OnlineBookingSystem::setDisplay(size_t) 调用manager.getNextCustomer()。因为您已将 Michael 添加到 manager 的另一个实例，所以这将返回 nullptr。

如何解决
您只需修改OnlineBookingSystem::getUserManager() 以返回指向manager 的指针而不是它的副本：

UserManager* getUserManager()
{
    return &manager;
}

然后修改调用代码以使用指针解引用运算符 (->) 而不是句点来访问 manager 上的方法。