C++ w Qt. Tworzenie obiektu, konstruktor.

Witam

Postaram się mój problem opisać jak najkrócej, chociaż nie jest to takie łatwe.

Nie rozumiem pewnego mechanizmu w QT. Chodzi mi o korzystanie z funkcji, których argumentem jest referencja na obiekt pewnej klasy.
Przykładowo chcemy narysować linie. Jej kolor, grubość, styl możemy ustawić tak:

    QPainter painter;
    QPen pen;
    pen.setWidth(2);
    pen.setStyle(Qt::SolidLine);
    pen.setBrush(Qt::blue);
    painter.setPen(pen);

Chciałbym teraz wziąźć po lupę funkcje setBrusch. Jej definicja wygląda tak.

void QPen::setBrush(const QBrush & brush)

Jak widać funkcja przyjmuje za argument referencje na obiekt klasy QBrush. Zatem pytanie brzmi dlaczego kompilator nie sygnalizuje błędu w powyższym przypadku, skoro potrzebna jest referencja na obiekt, a powyżej mamy wywołanie tylko z Qt core enum.
Poprawnie powinno być to wywołanie z konstruktorem jawnym czyli (też działa):

setBrush(QBrush(Qt::blue))

zgodnie z definicją

QBrush(Qt::BrushStyle style)

Można też funkcję tą użyć z konstruktorem nie jawnym:

QBrush c(Qt::blue);
pen.setBrush(c);

Czy kompilator domyśla się tego, że to obiekt QBrush i sam to sobie dopisuje ? Czy jest to jakieś niejawne działanie, dodatkowe przeładowanie?

dodanie znaczników <code class="cpp"> - Furious Programming

Strzelam, może to pomoże
explicit keyword

http://en.cppreference.com/w/cpp/language/explicit

No ok. Mamy przyczynę problemu explicit. Postudiuje problem głębiej. Dotychczas zrobiłem na swoją potrzebę experymentalny kod. I tam coś nie działa jak w Qt bezpośrednie pisanie wartości nigdzie nie ma explicit.

#include <iostream>
#include <string>
#define C cout <<
#define E << endl

using namespace std;

class przyklad
{
public:
    przyklad(const string &a, const string &b);
    przyklad();
    przyklad(const string &jakis);
    string a , b;

    void wypisz()
    {
        C "wartosc a" << a << " wartosc b " << b E ;
    }

    void funkskl(const int &g)
    {
        C " funkcja funkskl" E ;
        C  g E ;
    }
};

przyklad::przyklad(const string &a,const string &b): a(a) , b(b)
{
    C "konstruktor const string &a,const string &b" E;
    C a << b E ;
}
przyklad::przyklad(const string &jakis):a(jakis)
{
    cout << "kostruktor const string &jakis --- " << jakis << endl;
    cout <<"zmienna pod jakis --- " << jakis << endl;
}

przyklad::przyklad()
{}

/*******************************************************/
class przykladB
{
public:
    przykladB(const przyklad &obiekt);
    przykladB();
};
przykladB::przykladB(const przyklad &obiekt)
{
    C "konstruktorB obiektem" E ;
}
przykladB::przykladB()
{
    C "domyslny konsB" E;
}
/***********************************************/

int main()
{
    string zm = "lalol";

    przyklad k("kolo"); // dziala poprawnie
    przykladB c(k); // działa poprawnie
    przykladB x(przyklad("ddd", "ggg")); // dziala poprawnie z jawnym wywolaniem
    // przykladB z("kakala"); błąd chociaż klasa przyklad k /ma konstruktor jedno parametrowi const string &jakiś analogicznie do  QT powinno działać
   // przyklad u = "string" ;   również błąd


    return 0;
}

Edit:
Sprawdziłem. Niejawna konwersja zachodzi faktycznie dla funkcji, lecz nie zachodzi dla konstruktorów jak w przykładzie powyżej i jak w Qt. Czyli jeśli mamy np
konstruktor w pierwszej klasie A o definicji
A (int zmienna)
i konstruktor klasy B o definicji
B(A obiekt)
To nie możliwe jest wywołanie w main() np
B(4)
,ale możliwe jest wywołanie funkcji o definicji
funk(A obiekt)
w main()
funk(4)

Działą również z konstruktorem. Nie wiem jednak dlaczego wyskakują błędy kiedy parametrem jest "const string &zm", a poprawnie kiedy parametrem jest "const char *zm"

#include <iostream>
#include <string>
#define C cout <<
#define E << endl


using namespace std;

class A
{
public:
    string zm;
    int z ;
    A(int z);
    A(const char *slowo);
};

A::A(int z): z(z)
{
    C "liczba z" << z E;
}
A::A(const char *slowo)
{
    C "konstruktor klasy A char " << slowo E;
}


class B
{

public:
    B(const A &obiekt);
    B();



};
B::B(const A &obiekt)
{
    C "konstruktor klasy B " E;
    C obiekt.zm E;

}
B::B()
{}


void funk(A ob);

int main()
{

    B o("rrrrr");
    funk(4);

    return 0;
}
void funk(A ob)
{
    C "w funkcji " << ob.z E;
}