Fibonacci numbers (using class)

i want to write a program to compute the Fibonacci numbers (max 20 numbers).but i want to do it using a class.

i wrote this and i want your opinions.
it computes the Fibonacci numbers for given num and then prints the result.
should i change anything?

Code:

class fib
{
    private:
        int fibar[20];
    public:
        fib();
        void create_nums(int);
        void show(int);
};
void fib::show(int n)
{
        for(int i=0;i<n;i++)
    cout<<fibar[i]<<"\n";
}
fib::fib()
{
    memset(fibar,0,sizeof(int)*20);
    fibar[1]=1;
}
void fib::create_nums(int n)
{
        for(int i=2;i<n;i++)
    fibar[i]=fibar[i-2]+fibar[i-1];
}
main()
{
    fib obj;
    int num;

    cout<<"give N:";
    do{
        cin>>num;
        }while(num>20 || num<0);

        obj.create_nums(num);
        obj.show(num);
}

use a vector instead of a fixed length array

thanks for your reply.
I 'll change it.
something else?
about the implementation?

Firstly, it's int main(). Standard C++ does not have default return type (int as in C).

Secondly, this class relies too much on the user of the class getting things right. For example, the display function assumes that you have called the create function earlier with a value large enough. What if the user of the class makes a mistake and asks the class to output more values than he has created earlier?

One possibility here would be to make a create function private and call it from show to generate more fibonacci numbers as needed. If the user can only call the show function, and that takes care that the instance stores a sequence as long as requested, there are less ways to misuse the class.

Also the class relies on the user checking if the input to the methods is less than 20 - from the user's perspective it is a completely arbitrary value. They shouldn't know that the class has a private array of that size (though you might add a method that tells them that).

Then there's also const correctness. fibo::show doesn't change anything in the instance, so it should be declared a const method:

Code:

        void show(int) const;

It is also not a very good idea to omit variable names from function declarations. Looking at the class declaration I can see that the methods take an int parameter but what's it supposed to mean? OK, in this case I can guess, but that is not always the case.

If you switch to using a vector (dynamic size), you might also need to check for integer overflow. The fibonacci numbers grow very fast and you'll soon get a value that is larger than the int type can hold. Can you check whether the result of an addition would be larger than the type can hold?