Employee Test Driver Data Structures

Question

What would I use to define these Variables outside the Public and Private? Enum?

The Instructions for this section are this:

A default constructor. Remember that the default constructor for Address has the following initial values: Address to "99999 Sunset Boulevard" , "Beverly Hills", "CA", "99999"

4 private string instance variables for :Street, City, State, Zip A constructor with 4 parameters: one for street, one for city, one for state, one for zip.

A printAddress(): it prints the Street, City, State, and Zip

Here is what I got so far

class Address
{
  public:
    Address();
    Address(City defaultCity, State defaultState, Street defaultStreet, Zip, defaultZip);
    int getCity();
    int getState();
    int getStreet();
    int getZip();
    int printAddress();
  private:
    int Street, City, State, Zip;
};
 Address :: Address(City defaultCity, State defaultState, Street defaultStreet, Zip, defaultZip);
{
    defaultCity = City
    defaultState = State
    defaultStreet = Street
    defaultZip = Zip
}
 Address::Address()
{
   Street = "99999 Sunset Boulevard,";
   City = "Beverly Hills,";
   State = "CA,"; 
   Zip = "99999";
}
 int Address::getCity()
{
   return City;
}
 int Address::getState()
{
   return State;
}
 int Address::getStreet()
{
   return Street;
}
 int Address::getZip()
{
   return Zip;
}
 int Address::printAddress()
{
   return Street, City, State, Zip;
};

Also when he says "print" I assume he means display right?

Thank you

Answer 1

I would do it like this:

#include <iostream>
#include <string>

/********************
 *  File: Main.cpp  *
 ********************/

/*
 * For simplicity I put it all in one file.
 */

class Address
{
public:
    explicit Address();
    explicit Address(const std::string& city, const std::string& state,
        const std::string& street, const std::string& zip);
    const std::string& getCity() const;
    const std::string& getState() const;
    const std::string&  getStreet() const;
    const std::string&  getZip() const;
    void printAddress() const;
private:
    std::string street;
    std::string city;
    std::string state;
    std::string zip;
};

// Default Constructor
Address::Address() :
    city("Beverly Hills"),
    state("CA"),
    street("99999 Sunset Boulevard"),
    zip("99999")
{ }

Address::Address(const std::string& city, const std::string& state,
    const std::string& street, const std::string& zip) :
    city(city), state(state), street(street), zip(zip)
{ }

const std::string& Address::getCity() const
{
    return city;
}
const std::string& Address::getState() const
{
    return state;
}
const std::string& Address::getStreet() const
{
    return street;
}
const std::string& Address::getZip() const
{
    return zip;
}
void Address::printAddress() const
{
    std::cout << street << ", " << city << ", "
              << state << ", " << zip << std::endl;
};

int main(int argc, char* argv[]) {
    Address defaultAddress;
    defaultAddress.printAddress();

    Address customAddress("Cologne", "NRW", "Domplatz 1", "D-50668");
    customAddress.printAddress();

    return 0;
}

EDIT:

Explaining some changes.

1. Look at the private section of the class declaration. You declared members as int although they should be strings. I corrected that.

2. In the constructors you should use initialization lists to initialize members.

3. In your constructor parameter list you used the words City, State, Street and Zip as if they were types. Which they are not. The type of these parameters is std::string. Or in my case I chose const std::string& because I prefer passing by reference over passing by value if both are viable.

4. If methods do not change the object you may declare them const so they can be called also on const instances of the class or const references. I did so in this example when declaring the getters.

5. I did not see a need to return anything to the caller after printing so I changed the return type to void.

6. I added a main function to test the class.

There is probably a lot more to say about the differences, but I think this is enough for tonight.

Cheers!