Should I use std::size_t to count instance of my class?
<p>I have a class:</p>

<pre><code>class Nothing
{

    /// Constructor, Destructor, Copy and Assignment
    public:
    Nothing();
    ~Nothing();
    Nothing(const Nothing&amp; clone);

    /// Operators
    const Nothing&amp; operator=(const Nothing&amp; other);

    /// Static Members
    private:
    static unsigned long long id_counter;
    static unsigned long long instance_counter;
};


Nothing::Nothing()
{
    m_name.clear();
    id_counter ++;
    m_id = id_counter;

    instance_counter ++;
}

Nothing::~Nothing()
{
    m_name.clear();
    instance_counter --;
}

Nothing::Nothing(const Nothing&amp; other)
{

}

unsigned long long Nothing::id_counter = 0;
unsigned long long Nothing::instance_counter = 0;
</code></pre>

<p>Notice I am using unsigned long long to count instances of the class. Should I use std::size_t instead?</p>

<p>As an aside: If I have an instance of a class, and I do something like this:</p>

<pre><code>Nothing instance;
instance(Nothing()); // Calling copy constructor
</code></pre>

<p>Will the destructor be called before the copy constructor is called? Reason for asking is do I need <code>id_counter ++;</code> and <code>instance_counter ++;</code> inside of my copy constructor?</p>
