V>> Intellisense дает нам подсказку двух конструкторов, бери на здоровье. Лекарство состояло бы в принудительном переопределении базовых конструкторов как private. Тогда бы нарушалась инкапсуляция базового класса, ибо любые незначительные изменения в нем (скажем — ввод нового конструктора) потребовал бы доработки ВСЕХ наследников. И жили бы мы весело

VD>Да вариантов придумать можно много. Плохо что выбран был самый примитивный.

class DerivedClass : BaseClass {
  using base(...);  // сделать доступными ВСЕ базовые конструкторы, не пересекающиеся по сигнатурам с собственными

  using base();             // сделать доступными только определенные сигнатуры.
  using base(Type1, Type2);
}

class Rectangle
{
  public Rectangle( int width, int height );

  public int width();
  public int height();

  private int width_;
  private int height_;
};

class Square : Rectangle
{
  public Square( int size );
};

Array.IList.Add Method
Implements IList.Add. Always throws NotSupportedException.

D>B *b = new B();
b->>f(); // так нельзя -- ошибка компиляции
D>((A *) b)->f(); // а так уже можно
D>

public class BaseClass
{
  public BaseClass(int capacity) 
    {
      ...
    }
}

public class DerivedClass: BaseClass
{
  public DerivedClass(int); 
    // эквивалентно следующему:
  public DerivedClass(int capacity): base(capacity)
    {
    }    
    
}

public class BaseClass
{
    [Inherit]
  public BaseClass(int capacity) 
    {
      ...
    }
    [Inherit]
    public BaseClass(IEnumerable source)
    {
    }
}

public class DerivedClass: BaseClass
{
  // подразумеваемые конструкторы, предоставленные компилятором:
//  public DerivedClass(int capacity): base(capacity)
//    {
//    }    
//    public DerivedClass(IEnumerable source): base(capacity)
//    {
//    }
}
public class DerivedClass2: BaseClass
{
  // явное сокрытие конструктора:
  private DerivedClass2(int);
    // частичное сокрытие и снятие атрибута Inherit:
    [Inherit(false)]
    protected DerivedClass2(IEnumerable source);
}

class Base {
    int i;

    public Base(int i) { this.i = i; }

}

class Derived : Base {
    double readonly d;
    
    public Derived(int i, double d) : base(i) {
        this.d = d;
    }
}

If a class contains no instance constructor declarations, a default instance constructor is automatically provided. That default constructor simply invokes the parameterless constructor of the direct base class.

class Base
{
    public Base(bool someFlag)
    {}
}

class Derived
{
    public Derived() : base(true)
    {}
}

AVK>class Base
AVK>{
AVK>    public Base(bool someFlag)
AVK>    {}
AVK>}

AVK>class Derived
AVK>{
AVK>    public Derived() : base(true)
AVK>    {}
AVK>}
AVK>

        class Base
        {
            public Base(bool someFlag)
            {}
        }

        class Derived : Base
        {
            protected Derived(bool someFlag) : base(someFlag)
            {}

            public Derived() : base(true)
            {}
        }

struct A {
    virtual void f() {}
};

class B: public A {
    virtual void f() {}
};

B *b = new B();
b->f(); // так нельзя -- ошибка компиляции
((A *) b)->f(); // а так уже можно

class MyClass : BaseClass
{
  SomeClass someVar = new SomeClass();
}

VD>Есть класс являющийся базовым для типизированных коллекций. От него принципиально только наследуют конкретные классы коллекций. Паттерн такой. Каждая коллекция имеет свой тип. Ну, так вот. Класс дженерик и проблем казалось бы нет. Но вот хотелось бы чтобы конкретные коллекции предоставляли разные кострукторы. Ну, там один с capacity, другой с инициализирующими значениями, третий с сочетаниями первых двух и т.п., и т.д. Уж не промню сколько там было кострукторов, но было не мало. Коллекций от этого класса порождалось штук 10. И в каждой пришлось описывать те же самые конструкторы. В итоге куча кода на пустом месте. А до этого я их генерировал и проблем не знал. Вот тебе и "заюзал" передовые технологии (дженерики).

class Collection<T> {
    // a lot of constructors
}

class CollectionOfInt: Collection<int> {}
class CollectionOfLong: Collection<long> {}
class CollectionOfDouble: Collection<double> {}
// . . .

template<class T>
class Collection {
    // a lot of constructors
};

typedef Collection<int> CollectionOfInt;
typedef Collection<long> CollectionOfLong;
typedef Collection<double> CollectionOfDouble;
// . . .

Ага. Только на С++ проблема typedef-ами не решается. typedef не создает новый тип. Он только лишь дает алиас старому. При этом все типы у тебя будут равны. А требуется именно введение нового типа. Ну, и у конкретных типов коллекций могут переопределяться некоторые вируальные методы.

template< class T, class Tag >
struct strong_typedef : T
{
  strong_typedef( T const& t ) : T(t) { }

  template< class A1 >
  strong_typedef( A1& a1 ) : T(a1) { }

  template< class A1, class A2 >
  strong_typedef( A1& a1, A2& a2 ) : T(a1, a2) { }

  template< class A1, class A2, class A3 >
  strong_typedef( A1& a1, A2& a2, A3& a3 ) : T(a1, a2, a3) { }

  // . . .
};

struct my_unique_collection_tag;
typedef strong_typedef< Collection<int>, my_unique_collection_tag > MyUniqueCollection;

struct Base {
    int i;
    Base(int i_) : i(i_) {}
};

struct Derived : Base {
    using Base::Base;
};