Наследование конструкторов

#include <iostream>
class A {
public:
    A() {
        std::cout << "I'm A()\n";
    }
    A(int i) {
        std::cout << "I'm A(int)\n";
    }
};
class B: public A {
public:
    A * getA(int t) {
        return new A(t);
    }
};
int main() {
    B b;
    A * a = b.getA(11);
    return 0;
}

class Base1 {
public:
   // конструктор Base1() неявно удален потому что определен
   // пользовательський конструктор
   Base1(int) {}
};
 
class Derived1 : public Base1 {
 
};
 
class Base2 {
public:
   Base2() {}
   Base2(int) {}
};
 
class Derived2 : public Base2 {
 
};
 
int main()
{
   //Derived1 d1; // Error конструктор Derived1() неявно удален
   Derived2 d2;
}

class Base1 {
public:
   Base1() { std::cout << "Base1().\n"; }
   Base1(int) { std::cout << "Base1(int).\n"; }
};
 
class Derived1 : public Base1 {};
 
class Base2 {
public:
   Base2() { std::cout << "Base2().\n"; }
   Base2(int) { std::cout << "Base2(int).\n"; }
};
 
class Derived2 : public Base2 {
public:
   using Base2::Base2;
};
 
int main()
{
   //Derived1 d1(42); // Error. нету Derived1(int) и он не наследуется
   Derived1 d2; // Ok. Derived1() генерируется компилятором по умолчанию
   Derived2 d3(42); // Ok. Derived2(int) наследуется
}

#include <iostream>
#include <iomanip>
#include <windows.h>
using namespace std;
 
class Counter
{
protected:
    unsigned int count;
public:
    Counter() : count(0)
    { }
    Counter(int c) : count(c)
    { }
    unsigned int get_count() const
    {
        return count;
    }
    Counter operator++()
    {
        return Counter(++count);
    }
};
 
class CountDn : public Counter
{
public:
    Counter operator--()
    {
        return Counter(--count);
    }
};
 
int main()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    CountDn c1; // тут все ок, наследуется конструктор без арг-ов
    //CountDn c1(2); // а тут "отсутствуют экземляры конструктора с одним арг-ом"
    cout << "\n c1 =" << c1.get_count();
    ++c1; ++c1; ++c1;
    cout << "\n c1 =" << c1.get_count();
    --c1; --c1;
    cout << "\n c1 =" << c1.get_count();
    cout << endl;
    system("pause");
    return 0;
}

#include <iostream>
 
class Base
{
public:
    Base(int v) 
       : v_(v)
    {}
    
   
    int getV() const { return v_; }
    
private:
    int v_;
};
 
class Derived : public Base
{
public:
    //Если этот конструктор не определить, то будет ошибка. 
    //Т.к сгенерированный конструктор попытается вызвать конструктор без параметров базового класса.
    //Но его в нем нет, т.к. мы сами определили конструктор с одним параметром, 
    //взяв на себя дальнейшую ответственность за создание конструкторов в нем.
    Derived() : Base(12) {}
};
 
int main()
{
    Derived d;
    std::cout << d.getV();
}

std::cout << d.getV();

using namespace std;

#include <functional>
#include <iostream>
 
using namespace std;
 
int function()
{
     return 12;
}
 
int main()
{
    cout << function();
    return 0;
}