Что такое конструктор?

//Title of this code
//Compiler Version 18.00.21005.1 for x86
 
#include <iostream>
 
int main()
{
    std::cout << "Hello, world!\n";
    
    // --- информация о размере массива, 
    // и всех его размерностях известна времени компиляции
    // поэтому, нет ни одной причины хранить её в рантайме
    int ar[]={1,2,3};
    
    std::cout<<"size of array = " <<sizeof(ar)
        <<": elements = " << sizeof(ar)/sizeof(ar[0])
        <<'\n';
    
    
    // --- строго говоря, на языке с++ не существует динамических массивов
    // однако, часто так называют динамически 
    // выделяемые непрерывные блоки памяти
    
    size_t count = 10;
    int* dynArr = new int[count];
    
    // --- обратите внимание: 
    // мы не сообщали информацию о количестве элементов
    // тем не менее, компилятор каким то образом узнает эту рантайм информацию
    // как он это делает?
    delete[] dynArr;
    
    // --- стандарт оставляет это на откуп компиляторов
    // поэтому, рецепт получания данных - зависит от платформы.
    // например, для visual studio это можно сделать вот так:
    
    dynArr = new int[count];
    std::cout<<"size of array = " << _msize(dynArr) 
        <<": elements = " << _msize(dynArr) /sizeof(dynArr[0])
        <<'\n';
    
    delete[] dynArr;
    
    // --- ну и напоследок: некоторые ошибочно думают,
    // операция выделения памяти: new int[count];
    // выделяет sizeof(int[count]) памяти
    // это не верно.
    // единственное, что гарантирует стандарт - что её будет не меньше, 
    // чем было затребованно.
    // но реально может быть выделенно больше.
    // поэтому, приведенный выше код определения количества элементов
    // с использовании _msize, либо её аналогами для других платформ
    // теоретически может отработать не верно
}

#include <iostream>
using namespace std;
 
class single {
private:
    single() {}
    single(const single&) {}
    single& operator=(const single&) {}
public:
    static single *instance();
    int run() {
        cout << "hello" << endl;
    }
};
 
single* single::instance() {
    static single self;
    return &self;
}
 
int main() {
    single* ps = single::instance();
    return ps->run();
}

std::bind(&some::method, obj);

std::bind(&T::method, obj);

std::bind(&some::TNAME, obj); //<--- нельзя оторвать имя от типа, 
     //и передавать его как обособленный параметр

auto obj = T(param); // <--- здесь фигурирует запуск конструктора, 
  // но не фигурирует (и не может фигурировать) имя функции этого конструктора
 
 // T не может быть лексемой со значением "имя".
 // потому что ожидается тип.

auto obj = T(param); // T - совершенно спокойно может быть функцией

&T::M; //<--- нельзя сделать шаблон, 
// в который можно будет подставлять отдельно взятое имя M
// здесь только препроцессор спасает