Definition of static data members is not allowed inside class, why..?

As SA said the definition of static members is allowed. I was able to compile your code and it runs without any errors from the compiler. You should have described to us exactly what error your are seeing, that greatly helps us to provide the answer that you need. BTW, I am using Visual Studio 2010, but is should work the same way in other compilers.

This is what your code is doing. The static variable foo is initialized to 0. After you declare f1, f2 & f3 their constructors are called, in the constructors count is incremented. Since all three (f1, f2 & f3) are all incrementing the same variable, count winds up being equal to 3. Then when you call getcount for each one and send the result to the console you will see 3 for each one.

If you want to have the output be different for each call to getcount you need to do the increment of count somewhere other than the constructor. Or don't construct f1, f2 and f3 before doing the output. For example if you do the following you will get 1, 2, 3 for the output.

foo f1;
cout << "count is " << f1.getcount() << endl;
foo f2;
cout << "count is " << f2.getcount() << endl;
foo f3;
cout << "count is " << f3.getcount() << endl;

So that the console doesn't disappear after it runs you should add the following lines in your main method, just before the return statement:

std::cout << "Press ENTER to continue... " << flush;
std::cin.ignore( std::numeric_limits <std::streamsize xmlns:std="#unknown"> ::max(), '\n' );
</std::streamsize>

The console closing may not be an issue with all IDEs, but it does happen with Visual Studio.

[Edit- add more explanation of initialization]
From your comment you seem to be bothered by the initialization of the static class member, count. It is important to understand that a static class member cannot be initialized inside of the class. While this may seem odd, it is because a static class member really exists outside of any instance of the class. You are required to initialize a static class member or it will not be conspired to be in scope inside the class. The syntax is odd, but it does work as designed. Read this article[^] for some additional explanation.

[Edit- answer why static const data definition is allowed inside the class]
The variable, count, in your code is a member of the class and is therefore declared inside the class. When you make it a static class variable you are saying that every instance of the class will share that variable. So if f1 increments count the value will be one, then if f2 increments it the value will be two, if f3 looks at count next it will see a value of two.
Because count is a static class variable is exists outside of any instance of the class, in fact count exists before any instance of the class has been created. Because of this separation count must be initialized outside of the class so that count will have its initial value when the first instance of the foo class is created.

C++ allows the initialization of static members inside the class declaration only in case of static const integral values.

class CStaticTest
{
public:
    void Test()
    {
        printf("%s(%d)\n", __FUNCTION__, g_Member);
    }
private:
    static const int64 g_Member = 1;
};

Allowing the definition of static const integral values inside class declarations is also a new feature, not too long ago you had to resort to the unnamed enum trick to define an integer constant inside a class declaration:

class CStaticTest0
{
public:
    enum { MY_INTEGER_CONSTANT = 5 };
};

Sometimes you have to define the value of some constants in header files (in case of some frameworks that need macro magic and/or template magic). In this case you can define the value of a constant in the header file by using templates. static members of templates can be defined in header files (but the definition isn't inside the template class declaration):

template <typename T>
class TMyTemplate
{
public:
    void Test()
    {
        printf("%s(%s)\n", __FUNCTION__, g_Str.c_str());
    }
private:
    static const std::string g_Str;
};

template <typename T>
const std::string TMyTemplate<T>::g_Str = "MyVal";

Some header-only libraries make use of this latter feature. (/off I never understood why is it so good to write a library as header only... for other reason than increasing compile time of large projects... /on)

I think your question is badly worded. It appears you wish to know the number of the class instance. You could achieve that by doing this:

class foo
{
private:
    static int count;
    const int mycount;
public:
    foo() : mycount(++count)
    {
     }
    const int getcount() const
    {
        return mycount;
    }
};
 
int foo::count = 0;
 

int main()
{
    foo f1, f2, f3;
    cout << "count is " << f1.getcount() << endl;
    cout << "count is " << f2.getcount() << endl;
    cout << "count is " << f3.getcount() << endl;
 
    return 0;
}

When instances are deleted what happens to count? That's up to you.