checking for 'null' slots in a object array

Hi there I have come form the java camp and am trying to do a c++ program

I have an array called Manifest that tak开发者_JAVA百科es passenger objects

for (int i = 0; i< _totalSeats; i++) 
{
    if (Manifest[i] != instanceOf Passenger) {
        cout<<"empty"endl;
    }
    else {
        cout<< PassengerToString(i);
    }
}

obviously the 'instanceOf' is a problem in C++, I know is==null doesn't work as there is no such thing as null without being specificly inserted but to build a blank passenger objects then insert them in each array slot sounds messy and costly. Is there a more elegent way?

thanks

It sounds like you're mapping seats to passengers. This means a map may be a better choice, such as std::map<int, Passenger> Manifest.

for example

#include <map>
#include <string>
#include <iostream>
class Passenger
{
        public:
                std::string toString() const
                {
                        return "Passenger";
                }
};

int main()
{
        std::map<int, Passenger> Manifest;
        Manifest[2] = Passenger();
        int _totalSeats = 10;

         for (int i = 0; i< _totalSeats; i++)
         {
             if (Manifest.count(i))
                     std::cout << Manifest[i].toString() << '\n';
             else
                     std::cout << "empty\n";
         }
}

test run: https://ideone.com/XkNOg

You can't really create an array of objects in C++ without constructing them all (well, actually, you can, but it's ugly, black magic stuff.) Don't use arrays -- use std::vector.

You can have null in C++, provided you hold object pointers.

struct Passenger
{
    std::string name_;
};

std::string PassengerToString(const Passenger& p)
{
    return p.name_;
}


int main() 
{


    const int _totalSeats= 10;
    Passenger* Manifest[_totalSeats]  = {0};

    for (int i = 0; i< _totalSeats;i++)
    {
        if (Manifest[i] != 0)
        {
            std::cout<<"empty" << std::endl;
        }
        else
        {
            std::cout<< PassengerToString(*Manifest[i]) << std::endl;;
        }


    }

    return 0;
}

For real production code, you would use something like shared_ptr<>, but for an exercise in learning C++ post Java, doing this the low level way using raw pointers might be instructive.

The cleanest way, would be to only store objects that are valid in the container. So, instead of using a fixed-size array, you can use a std::vector<Passenger> and add and remove Passengers to it as needed.

If the position of the Passenger objects is important (i.e., the index is important), you can easily use a std::map<int, Passenger>.

Otherwise, there are numerous approaches to solve the problem:

• Use a container of smart pointers (for example, std::vector<std::unique_ptr<Passenger>> or std::vector<std::shared_ptr<Passenger> >) or a pointer container (for example, boost::ptr_vector<Passenger>) and store pointers to dynamically allocated objects.

• Use a designated "null object" (the approach you describe). Whether the "null object" is the default state of the object or an explicitly set state is up to you.

• Use a container of struct { bool valid_; Passenger object_; }; as a crude "optional" type wrapper (this requires Passenger to be default constructible but does not require the default constructed object to be meaningful).

• Use Boost.Optional

Thank you all for you assistance

I was restricted in what data structures I was allowed to use (I thought a map would have been a much better choice but they chose array....)

here is how I solved the problem in the end

as Friedman-hill so correctly mentioned when I dynamicly created my array it required a blank constructor of type Passenger to initalise. I simply added a private data member bool "isEmpty" initalised to false to my consturctor. then checked like so:

if (!Manifest[i].getIsEmpty())

thanks again