Explicit и его назначение

class lessons {
    int intVar;
    bool boolVar;
public:
    lessons() {}
    explicit lessons(int iVar, bool bVar = true) : intVar(iVar), boolVar(bVar) {}
};

lessons A = 15;

lessons A = lessons(15);

lessons(15);

class lessons {
    int intVar;
    bool boolVar;
public:
    lessons() {puts(__PRETTY_FUNCTION__);}
    lessons(int iVar, bool bVar = true) :
       intVar(iVar), boolVar(bVar) {puts(__PRETTY_FUNCTION__);}
    lessons(const lessons &rhs) :
    intVar(rhs.intVar), boolVar(rhs.boolVar) {puts(__PRETTY_FUNCTION__);}
};
 
int main()
{
   lessons A = 15; // lesson::lessons(int, bool)
}

//Title of this code
//g++  4.8.2
 
#include <iostream>
using namespace std;
 
struct example
{
    example(int) { cout <<"ctor with patam\n"; }
private:
    example(const example&){ cout <<"copy\n"; }
    
};
 
int main()
{
    std::cout << "Hello, world!\n";
 
    // error: ‘example::example(const example&)’ is private    
    example e = 10;
    
}

example e = 10;

example e = example(10); //<--- explicit ctor

example e(example(10)); //<--- copy ctor(explicit ctor)

example e(example(10));

example e(10);

#include <iostream>
using namespace std;
 
 
struct foo {}; //<--- не умеет выводится в поток
 
struct bar  //<--- умеет выводится в поток
{
    template<class T> using Stream = ::std::basic_ostream<T>;
    
    template<class T> friend
        Stream<T>& operator<<(Stream<T>& os, const bar& obj ) { return os<<"bar"; }
    
    bar(){}
    bar(const foo&){} //<--- и может построится на основании foo, 
         //который не умеет выводится в поток
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    const foo f;
    const bar b;
    
    cout << b << endl;  //<--- здесь все нормально и предсказуемо
    
    
    cout << f << endl; //<--- а вот здесь лажа
    
    //компилятор гцц почему то считает, что раз foo не умеет выводиться в поток,
    //значит можно взять любую перегрузку, аргумент которой может построится из foo
    //и использовать её
    
    //по итогу получаем сюрприз: строительство временного объекта
    // и вывод в поток совершенно не того типа, который по смыслу нужно было выводить
    
}

void foo(const ::std::string& s)   //<--- принимает строку
{
    cout<< "text = "<<s<<endl; 
} 
 
...
 
foo("hello"); //<--- мы хотим вызвать foo, 
   // передав неизменяемый массив типа char, вместо строки
   // просто потому, что нам так удобно
   // и мы ожидаем, что компилятор самостоятельно выполнит приведение

#include <iostream>
using namespace std;
 
struct bar;
 
template<class T,class U> struct only_bar;
 
template<class U> struct only_bar<bar,U>
{
    typedef ::std::basic_ostream<U> 
        ret; 
};
 
#define ONLY_FOR_BAR \
    typename only_bar<T,U>::ret&
    
 
struct foo {};
 
struct bar  
{
    template<class T> using Stream = ::std::basic_ostream<T>;
    
    template<class T,class U> friend
        ONLY_FOR_BAR
            operator<<(Stream<U>& os, const T& ) { return os<<"bar"; }
    
    bar(){}
    bar(const foo&){}
};
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    //const foo f;
    const bar b;
    
    cout << b << endl; 
    //cout << f << endl; 
}