Which of the following is true?

Which statement is true for the static member function?

The output of the below code?

#include <iostream>
class X
{
public:
    void foo();
};
static void X::foo()
{
    std::cout<<"foo() is static function\n";
}

int main()
{
    X::foo();
    return 0;
}

Which is the correct syntax to access the static member functions with the class name?

If static data member are made inline, ______________

Predict the output of the below code.

#include <iostream>
using namespace std;

class Y
{
private:
    int id;
    static int next_id;
public:
    int getID()
    {
        return id;
    }
    Y()
    {
        id = next_id++;
    }
};
int Y::next_id = 1;

int main()
{
    Y obj1;
    Y obj2;
    Y obj3;
    cout << obj1.getID() << " ";
    cout << obj2.getID() << " ";
    cout << obj3.getID();
    return 0;
}

What is the output of the below code?

#include <iostream>
using namespace std;

class Y
{
private:
    int m_x;
public:
    Y(int x)
    {
        m_x = x;
    }
    int get()
    {
        return m_x;
    }
};

class X
{
    static Y a;
public:
    static int get()
    {
        return a.get();
    }
};

int main()
{
    X b;

    cout << b.get();

    return 0;
}

If a static data member is declared thread_local there is one copy of the member per thread.

Which among the following is true?

If a static data member is not declared thread_local there is one copy of the data member that is shared by all the objects of the class.

What is the output of the below code?

#include <iostream>
using namespace std;

class Y
{
    static int x;
public:
    Y()
    {
        x++;
    }
    static int getX()
    {
        return x;
    }
};

int Y::x = 0;

int main()
{
    cout << Y::getX() << " ";
    Y obj[3];
    cout << Y::getX();
    return 0;
}

The static member functions __________________

The static data member _________________

Are static members obey the class rule?

Which statement is true for static members?

What is the output of the below code?

#include<iostream>
using namespace std;

class X
{
private:
    static int count;
public:
    X& fun();
};

int X::count = 10;

X& X::fun()
{
    X::count++;
    cout << X::count << " ";
    return *this;
}

int main()
{
    X obj;
    obj.fun().fun().fun().fun();
    return 0;
}