Classes & Constructors

[dhuan]

first i coded this in C# (just so i could get warmed up with the basic stuff i learned from constructor lessons)

using System;

namespace myProgram
{
    class Person
    {
        private string name;
        private int age;

        public Person()
        {
            this.name = "Unknown";
            this.age = 0;
        }

        public Person(string name, int age)
        {
            this.name = name;
            this.age = age;
        }

        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public int Age { get { return age; } set { this.age = value; } }

        public static void Introduce(Person obj)
        {
            Console.WriteLine("Hi, my name is "+obj.name+", I am "+obj.age+" years old.");
        }
    }

    class Program
    {
        public static void Main()
        {
            Person p1 = new Person();
            Person p2 = new Person("Jack Wilson",40);
            Person.Introduce(p1);
            Person.Introduce(p2);
        }
    }

}

it works as expected. Then I decided to translate it to C++, and this is the best i could come up with:

#include <iostream>
using namespace std;

class Person
{

    private:
        string name;
        int age;


    public:
        Person();
        Person(string, int);
        string getName(){ return name; }
        int getAge(){ return age; }

        static void Introduce(Person);
};

Person::Person()
{
    this->name = "Nameless";
    this->age = 0;
}

Person::Person(string name, int age)
{
    this->name = name;
    this->age = age;
}

void Person::Introduce(Person obj)
{
    cout<<"Hello, my name is "<<obj.getName()<<", I am "<<obj.getAge()<<" years old."<<endl;
}

int main()
{
    Person p1 = Person();
    Person p2 = Person("Jack Wilson",40);
    Person::Introduce(p1);
    Person::Introduce(p2);
}

Which works, as well.
Well then, i just posted this so that maybe you veterans could clue me in on how to make it cleaner.

[Elysia]

"this->" is not needed inside your functions.
You're missing set for age/name.
You should use references where possible.
Introduce should not be static (why would you do that?).
And do not leave out parameter names:
>>Person(string, int);
should be:
Person(const string& name, int age);

>>Person p2 = Person("Jack Wilson",40);
Better written as
Person p2("Jack Wilson",40);

And
>>Person p1 = Person();
as
Person p1;
No parentheses here! Doing so will not do what you expect.

[laserlight]

Which works, as well.
Well then, i just posted this so that maybe you veterans could clue me in on how to make it cleaner.

I would suggest something like this:

#include <string>

class Person
{
public:
    Person() : name("Nameless"), age(0) {}
    Person(const std::string& name_, int age_) : name(name_), age(age_) {}

    std::string getName() const
    {
        return name;
    }

    int getAge() const
    {
        return age;
    }
private:
    std::string name;
    int age;
};

#include <iostream>

void introduce(const Person& person)
{
    using namespace std;
    cout << "Hello, my name is " << person.getName()
        << ", I am " << person.getAge() << " years old." << endl;
}

int main()
{
    Person p1;
    Person p2("Jack Wilson", 40);
    introduce(p1);
    introduce(p2);
}

Notice:

• The #include <string>
• The using directive was moved to after the class definition (and in fact made local to a function) since the class definition might eventually go into a header.
• The use of construction initialiser lists.
• The use of const reference parameter for std::string and Person types.
• That getName and getAge were declared const.
• That the static member function was changed to a free function since it can work through the interface of the class without accessing its internals.
• The initialisation of the Person objects has been simplified.

EDIT:

You're missing set for age/name.

Whether these are actually missing depends on whether objects of this Person class are designed to be immutable, but either way it is something to think about.

[dhuan]

Thank you all for your answers.
One thing though laserlight, I always thought that reference parameters should only be used when you want to modify the variable that's being passed. In this case, what's the use of referece parameters?

void introduce(const Person& person)
{

[Elysia]

It avoids the overhead of copying the parameter. By specifying const, you make sure you don't accidentally modify it (among other things).

[Xupicor]

The point is - you avoid copying the object, which may hurt the performance of your program.
edit: Ah, beat me to it.

[dhuan]

Got it.

>>Person p2 = Person("Jack Wilson",40);
Better written as
Person p2("Jack Wilson",40);

Does it change anything other than having to type less?

And
>>Person p1 = Person();
as
Person p1;
No parentheses here! Doing so will not do what you expect.

Won't it? What's the difference in this case? Won't both ways call the constructors?

[Elysia]

Does it change anything other than having to type less?

Technically, it would create an object, a temporary, and assign it to the variable. Nevertheless, compilers would usually optimize that. So it usually amounts only to less typing.

Won't it? What's the difference in this case? Won't both ways call the constructors?

Consider:

Person p1(); // Function prototype for p1

int main()
{
    Person p1(); // Create p1 object.
    // ... Use p1 ...
}

Person p1() { return Person(); }

Compare the function prototype and your p1 variable declaration. Similar, aren't they?
So while it looks perfectly valid to create an object that way, it's really a pitfall in the language!

[whiteflags]

Person p1(); // Function prototype for p1

Correct. As a matter of fact, that will always look like a function prototype to the compiler, it doesn't matter what context it appears. Leaving off the parens is not a matter of style. Further, if you must use a temporary to create another type of object, then:

Foo x = Bar();

is actually correct in C++'s grammar.

[dhuan]

Well, i've done some upgrades on my code based on what i learned from you guys (i still wanna leave that "Introduce" function as static, so i can can call it directly from the class.)

#include <iostream>
using namespace std;

class Person
{

    private:
        string name;
        int age;


    public:
        Person();
        Person(string, int);
        string getName(){ return name; }
        int getAge(){ return age; }

        static void Introduce(const Person&);
};

Person::Person()
{
    this->name = "Nameless";
    this->age = 0;
}

Person::Person(string name, int age)
{
    this->name = name;
    this->age = age;
}

void Person::Introduce(const Person& obj)
{
    cout<<"Hello, my name is "<<obj.getName()<<", I am "<<obj.getAge()<<" years old."<<endl;
}

int main()
{
    Person p1;
    Person p2("Jack Wilson",40);
    Person::Introduce(p1);
    Person::Introduce(p2);
}

Now I seem to be having problem with this line:

    cout<<"Hello, my name is "<<obj.getName()<<", I am "<<obj.getAge()<<" years old."<<endl;

This is what the compiler says:

error: passing `const Person' as `this' argument of `std::string Person::getName()' discards qualifiers|

[whiteflags]

The Introduce function uses const references when it calls the stuff on that line. In order to be const correct, the compiler enforces a rule that const objects only use const methods. When you have a method that does not change the object, you modify it with const like so:

        string getName() const { return name; }
        int getAge() const { return age; }

Then const objects can use it without an error.

[Elysia]

Code suggestions:

#include <iostream>
using namespace std;

class Person
{

    private:
        string m_name;
        int m_age;


    public:
        Person();
        Person(string name, int age);
        string getName() const { return m_name; }
        int getAge() const { return m_age; }
        string SetName(const std::string& name) { m_name = name; }
        int SetAge(int age) { m_age = age; }

        void Introduce() const;
};

Person::Person(): m_name("Nameless"), m_age(0)
{
}

Person::Person(string name, int age): m_name(name), m_age(age)
{
}

void Person::Introduce()
{
    cout<<"Hello, my name is "<< getName() << ", I am " << getAge()<<" years old." << endl;
}

int main()
{
    Person p1;
    Person p2("Jack Wilson",40);
    p1.Introduce();
    p2.Introduce();
}

Changes:
- Added prefix m_ to member variables to distinguish them from local variables.
- Added names of parameters to member functions and constructors.
- Used initializer list instead of assignment in constructors.
- Changed Introduce to a non-static member function.
- Added const correctness.
- Added setters.
- Changed code in main to reflect changes in class.

Setters can be good or bad. You should reflect on whether you want the creator to be able to change the contents of the class after it's created.
Code may contain some errors.

[laserlight]

i still wanna leave that "Introduce" function as static, so i can can call it directly from the class.

I don't understand your reasoning here. What do you mean by "call it directly from the class"?

- Added prefix m_ to member variables to distinguish them from local variables.

Note that this is a matter of subjective style. Not decorating member variables in this way (or any other way) is fine.

- Changed Introduce to a non-static member function.

Note that this is not an improvement: the member function still has access to the internals of the class when it could have done with just the public interface.

[Elysia]

Note that this is not an improvement: the member function still has access to the internals of the class when it could have done with just the public interface.

It makes more sense to have it non-static, and that is all I wanted to show.
Making it a non-class member might be more wise, still. But you already mentioned that.