_>Вот, думаю, тролль Отличная приманка для священной войны.

Впервые с зыком С++ я столкнулся почти 15 лет назад (почуствуйте какой стаж начав работать на Turbo C++. Тогда из доступной литературы по объектно-ориентированному программированию у меня было очень хорошее (как мне тогда казалсь) руководство по ООП на Turbo Pascal 5.5.

Со временем пришло понимание, что на С++ иначе просто нельзя !!! Средства, изначально заложенные в сам язык, настолько негибки и жестки, что реализовывать системы, требующие гибкости на С++ было крайне тяжело и постояннно приводило к кривым способам (т.е. это бага а фича .

Только вот как понимать ОО — я не думаю, что программисты, пишущие на Smalltalk'е, сочтут С++ объектно- ориентированным языком. Даже по сравнению с Java С++ явно в проигрыше — нет интерфейсов (зато есть множественное наследование со всеми его проблемами), объектная модель просто отсутствует.

Даже по сравнению с Java С++ явно в проигрыше

Много ли Вы знаете простых и удобных persistence-библиотек для С++, которые бы сами могли сериализовать произвольные объекты ? Максимум, что есть, это сложные библиотек с кучей ограничений и необходимостью вручную (зачастую при помощи макросов) задавать фактически часть метаинформации.

А вот в Smalltalk'е или в Python'е таких библиотек полно.

А как дела у С++ с интеграцией со скриптовыми языками

Кроме того, С++ вообще не различает два существенно РАЗНЫХ понятия — абстрактнывй тип данных (АТД) и объект.

А вот в Objective-C (другой вариант построения объектно-ориентированного языка на основе С, только в нем используется объектная модель языка Smalltalk) можно прямо на ходу узнать какие интерфейсы поддерживает объект, какие у него есть методы. Можно даже прямо на ходу добавить новый метод. И это компилируемый язык, весь графический интерфйес таких операционных систем как NeXTSTEP и Mac OS X построен именно на этом языке.

С другной стороны, посмотрев на С++, становится понятно, почему делегирование замалчивалось. А как его можно реализовать на С++, как можно попросить какой-то объект вызвать какой-то метод (даже, если список входных параметров у него точно такой же) ?

В С++ это практически невозможно сделать. Именно поэтому сперва в Delphi и C++ Builder, а затем и в остром С появилось возможность делегирования как расширение языка.

void func1 ( A& a );

void func2 ( A a );

В чем разница между этими описаниями (кроме того, что возможно программист просто пропустил символ '&') ?

void f(String s)
{
    s = "I'm dummy";
}

Есть примеры на STL, когда эффективность на простых строковых операциях падала в десятки раз.

Т.е. на С++ МОЖНО писать очень эффективно. И НЕКОТОРЫЕ даже пишут. Вопрос только — относитесь ли Вы к их числу ?

ГВ>template<typename T, ...> class Property : public PropertyBase<T> { ... };

ГВ>temaplate<typename T, ...> class MySmartProperty : public Property<T> {
ГВ>  private:
ГВ>    // Предположим, что такая проперть имеет какую-нибудь хитрую функцию,
ГВ>    // вызываемую, например, при изменении значения:
ГВ>    void HiddenSmartFunc() { ... }
ГВ>};

ГВ>// Тогда тестовая функция может выглядеть так:
ГВ>void MyTestFunc(PropertyBase<int> *prop){
ГВ>  *prop = 42;
ГВ>  // Проверяем - вызвалась ли HiddenSmartFunc
ГВ>}
ГВ>

void MyTestFunc(Action<int> propSet)
{
  propSet(42);
}

MyTestFunc((int i) =>{myObj.MyProp = i});

void ManageEnabled(Action<bool> propOK, Action<bool> propCancel) {
  if (someCondition)
  {
    propOK(true);
    propCancel(false);
  }
  else if (otherCondition)
  {
    propOK(false);
    propCancel(true);
  }
  else // strangeCondition
  {
    propOK(false);
    propCancel(false);
  }
}

ГВ>template<typename P1, typename P2>
ГВ>void ManageEnabled(P1 &propOK, P2 &propCancel) { ... }
ГВ>

bool bOK = false, bool bCancel = false;

someCondition = true; // Это упрощение - я имею в виду, что мы привели тестовое окружение в состояние,
// когда внутреннее условие someCondition станет true.
var propOk = (bool b)=>{bOK=b;};
var propCancel = (bool b)=>{bCancel=b;};
ManageEnabled(propOk, propCancel);

TEST_ASSERT(bOK && !bCancel);

otherCondition = true;

ManageEnabled(propOk, propCancel);

TEST_ASSERT(!bOK && bCancel);

someCondition = false;
otherCondition = false;

ManageEnabled(propOk, propCancel);

TEST_ASSERT(!bOK && !bCancel);

A>вот тут осторожней ведь в ответ могут поставить условие чтобы твой код на C# c linq компилировался хотя бы тремя современными С# компиляторами хотя бы на трех архитектурно разных платформах

class Test
{
    // outside the scope of class Test, 
    // set and get are both public
    typedef ::Property<    
        ::Test, 
        ::Number_Accessor<::Test>, 
        ::Number_Accessor<::Test>::value_type> Property_Number;

    // outside the scope of class Test, 
    // set is public and get is private
    typedef ::Property_Set_Public<    
        ::Test, 
        ::Number_Accessor<::Test>, 
        ::Number_Accessor<::Test>::value_type> Property_Set_Public_Number;

    // outside the scope of class Test, 
    // set is private and get is public
    typedef ::Property_Get_Public<    
        ::Test, 
        ::Number_Accessor<::Test>, 
        ::Number_Accessor<::Test>::value_type> Property_Get_Public_Number;

public:
    Property_Number               Number_A;
    Property_Set_Public_Number    Number_B;
    Property_Get_Public_Number    Number_C;
};

public class Test
{
   public int Number_A { get; set; }
   public int Number_B { private get; set; }
   public int Number_C { get; private set; }
}

ГВ>for (int i = 0; i < Count; i++)
ГВ>{
ГВ>    s = sb.ToString();
ГВ>}

ГВ>

            const long count = 10000000;

            var sb = new StringBuilder();
            
            sb.EnsureCapacity(10000);

            for (int i = 0; i < 50; ++i)
                sb.Append("01234567890123456789012345678901234567890123456789");
            
            String s, s1;

            var stopwatch = new Stopwatch();

            stopwatch.Start();
            
            s = sb.ToString();
            for (int i = 0; i < count; i++)
            {
                s1 = s.Substring(0, s.Length);
            }
            
            stopwatch.Stop();
            
            Console.WriteLine("Elapsed {0}", stopwatch.Elapsed);
            Console.WriteLine("Copied chars: {0}", sb.Length * count);
            Console.WriteLine("Average copy speed {0} MB/s", (sb.Length * count * 2) / stopwatch.Elapsed.TotalMilliseconds / 1000);

C>int? a = 1;
C>int c = 10;
C>int? b = (a == null ? a : c) / 100;
C>

    int a = 0;
    int c = 10;
    int b = 0;
    (*(&b)) = ( &a == NULL ? *(&a) : c) / 100;

Nullable types can represent all the values of an underlying type, and an additional null value. Nullable types are declared in one of two ways:
System.Nullable<T> variable
-or-
T? variable

catch(Exception e) {
   Log.Error(e); // через рефлексию будет собрана информация об исключении, потоке, методе, сборке, стеке вызовов(!!!)
   throw;
}

    [JsonObject(MemberSerialization.OptIn)]
    public class LoginResult
    {
        private ResultErrors errors = new ResultErrors();

        [JsonProperty("success")]
        public bool Success { get; set; }

        [JsonProperty("errors")]
        public ResultErrors Errors
        {
            get { return errors; } 
        }
    }

C>а в чём разница между func1(a) и func1(a.clone()), в том что в первом варианте кодер забыл вызвать клон

C>void f(String s)
C>{
C>    s = "I'm dummy";
C>}
C>

Интерфейс — набор всех сигнатур, определенных операциями объекта. Интерфейс описывает множество запросов, на которые может отвечать объект.

alarmNotifier += GUIHandler.onAlarm;
alarmNotifier += CoreRoutine.onAlarm;

C>Ой, а никак, и даже костыли такие не выпускают, фабрика ещё не открылась, ну ничё, когда дядя Билл захочет нам это надо будет

  macro @while (cond, body)
  syntax ("while", "(", cond, ")", body) 
  {
    def loop = Nemerle.Macros.Symbol (Util.tmpname ("while_"));

    <[ 
      ($("_N_break" : global) : {
        def $(loop : name) () : void {
          when ($cond) {
            ($("_N_continue" : global) : {
              $body
            }) : void;
            $(loop : name) ()
          }
        } 
        $(loop : name) (); 
      }) : void
    ]>
  }

  partial internal class Optimizer
  {
    public static CanInline(name : string, grammar : Grammar) : bool
    {
      def canInline(rule, recRules)
      {
        match (rule : Rule)
        {
        | Call(name)               =>
          if (recRules.Contains(name))
            false;
          else
            canInline(grammar.GetRule(name), recRules.Add(name));
        | Choice(rules)            => rules.ForAll(rule => canInline(rule, recRules));
        | Sequence(rules)          => rules.ForAll(rule => canInline(rule, recRules));
        | Capture(_, rule)         => canInline(rule, recRules);
        | RepeatMin(_, rule)       => canInline(rule, recRules);
        | RepeatMinMax(_, _, rule) => canInline(rule, recRules);
        | Not(rule)                => canInline(rule, recRules);
        | And(rule)                => canInline(rule, recRules);
        | Chars                    => true;
        | ExtensionPoint           => true;
        }
      }
      canInline(grammar.GetRule(name), Set().Add(name));
    }

    public static OptimizeRule(rule : Rule, grammar : Grammar) : Rule
    {
      def optimize(_ : Rule)
      {
      | Choice(rules) =>
        def rules = rules.Map(optimize);
        def rules = rules.Map(fun(_)
        {
        | Rule.Choice(rules) => rules;
        | rule => [rule];
        });
        def rules = rules.Flatten();
        def catChars(_)
        {
        | Rule.Chars([chars1]) :: Rule.Chars([chars2]) :: rules =>
          catChars(Rule.Chars([chars1.Sum(chars2)]) :: rules);
        | rule :: rules =>
          rule :: catChars(rules);
        | [] => [];
        }
        def rules = catChars(rules);
        match (rules)
        {
        | [rule] => rule;
        | _      => Rule.Choice(rules);
        }

      | Sequence(rules) =>
        def rules = rules.Map(optimize);
        def rules = rules.Map(fun(_)
        {
        | Rule.Sequence(rules) => rules;
        | rule => [rule];
        });
        def rules = rules.Flatten();
        def catChars(_)
        {
        | Rule.Chars(chars1) :: Rule.Chars(chars2) :: rules =>
          catChars(Rule.Chars(chars1.Append(chars2)) :: rules);
        | rule :: rules =>
          rule :: catChars(rules);
        | [] => [];
        }
        def rules = catChars(rules);
        match (rules)
        {
        | [rule] => rule;
        | _      => Rule.Sequence(rules);
        }

      | RepeatMin(min, rule)         => Rule.RepeatMin(min, optimize(rule));
      | RepeatMinMax(min, max, rule) => Rule.RepeatMinMax(min, max, optimize(rule));

      | Not(Not(rule))         => optimize(Rule.And(rule));
      | And(Not(rule))         => optimize(Rule.Not(rule));
      | Not(And(rule))         => optimize(Rule.Not(rule));
      | And(And(rule))         => optimize(Rule.And(rule));
      | Not(rule)              => Rule.Not(optimize(rule));
      | And(rule)              => Rule.And(optimize(rule));

      | Capture(name, rule)    => Rule.Capture(name, optimize(rule));
      | Chars as rule          => rule;
      | ExtensionPoint as rule => rule;

      | Call(name)             =>
        if (CanInline(name, grammar))
          optimize(grammar.GetRule(name));
        else
          Rule.Call(name);
      }
      optimize(rule);
    }
  }

C>Именно поэтому два первых на сегодняшний день скончались а третий живёт только за счёт огромных вложений

C>а сделайте ка мне аллокатор на шарпе дорогой

int i = 1;
E>i |= ( 1 << 4 );

var i = "hello";
i += " world";

E>В STL std:vector требует семантику значения (это как у чисел) от своих элементов, и сам, в свою очередь, имеет такую семантику. Так, например, возможен вектор векторов.

E>Кста, в С++ нет проблем задавать строку в виде списка. Мало того, stl::basic_string не обязана хранить строку в массиве... Просто таких реализаций stl нет, я думаю потому, что они не нужны...

E>Да нет, я вообще не вижу разницы между списком и массивом. Если тебе список букв милее, пусть будет список. Любой контейнер для хранения ПОСЛЕДОВАТЕЛЬНОСТИ элементов годится. Мы же о семантике говорим вроде, а не о чём-то ещё? Какая тогда разница, как именно это реализовано?

E>Кста, по поводу того, что про сценарии со строками мы знаем намного больше чем про сценариями с последовательностями букв -- хотелось бы поконкретнее этот тезис чтобы был развёрнут! А то как-то не понятно что мы такое знаем про строки, чего про последовательности букв не знаем...

E>ПОЧЕМУ нужны иммутабельные и нет строки, но НЕ НУЖНЫ иммутабельные последовательности букв?

E>Например я могу назвать фреймворк, который был разработан после появления С++ и строки там мутабельные, так же как и числа: MFC, STL, ATL, QT... хватит?

Х>>чем больше я вижу твоего С++ кода, тем больше понимаю почему тебе было мучительно больно на нём писать и ты перелез на C#

const int Count = 25000;

StringBuilder stringBuilder = new StringBuilder();
String[] s = new String[Count];

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();

for (int i = 0; i < Count; i++)
{
  stringBuilder.Append("c1");
  s[i] = stringBuilder.ToString();
}

stopwatch.Stop();

Console.WriteLine("append: elapsed {0}", stopwatch.Elapsed);
Console.WriteLine(stringBuilder.Length);

static const size_t count = 25000;

std::vector<std::wstring> wv;
std::wstring ws;

DWORD dwStart = ::GetTickCount();

for(int i = 0; i < count; ++i)
{
  ws.append(L"c1");
  wv.push_back(ws);
}

DWORD dwEnd = ::GetTickCount();

std::cout << (dwEnd - dwStart) << " ms" << std::endl;

String s;
// ...
for (int i = 0; i < Count; i++)
{
  stringBuilder.Append("c1");
  s = stringBuilder.ToString();
}

std::wstring ws1;
for(int i = 0; i < count; ++i)
{
  ws.append(L"c1");
  ws1 = ws;
}

Х>>>чем больше я вижу твоего С++ кода, тем больше понимаю почему тебе было мучительно больно на нём писать и ты перелез на C#

ГВ>String[] s = new String[Count];
ГВ>

ГВ>std::vector<std::wstring> wv;
ГВ>

            const int count = 5000;

            var stringBuilder = new StringBuilder();
            var s = new List<string>(count);

            var stopwatch = new Stopwatch();
            stopwatch.Start();

            for (int i = 0; i < count; i++)
            {
                stringBuilder.Append("Карл у Клары украл кораллы в количестве ");
                stringBuilder.Append(i);
                stringBuilder.AppendLine(" штук");
                
                s.Add(stringBuilder.ToString(0, stringBuilder.Length));
            }

            stopwatch.Stop();

            Console.WriteLine("append: elapsed {0}", stopwatch.Elapsed);

inline std::wstring StringToWString(const std::string& s)
{
    std::wstring temp(s.length(),L' ');
    std::copy(s.begin(), s.end(), temp.begin());
    return temp;
}

int _tmain(int argc, _TCHAR* argv[])
{
    static const size_t count = 5000;

    std::vector<std::wstring> wv;
    std::wstring ws;
    std::string temp;
    char buffer[20];
    DWORD dwStart = ::GetTickCount();


    for(int i = 0; i < count; ++i)
    {
      ws.append(L"Карл у Клары украл кораллы в количестве ");
      _itoa_s(i,buffer,10);
      temp = buffer;
      ws.append(StringToWString(temp));
      ws.append(L" штук\n");
      wv.push_back(ws);
    }

    DWORD dwEnd = ::GetTickCount();

    std::cout << (dwEnd - dwStart) << " ms" << std::endl;
}

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

CC>>>>В С++ ничего не мешает заимплементить точно такую же функциональность как для строк C#: все методы, меняющие строку — возвращают новую строку а оригинал не трогают.
C>>>Кстати, хотел бы я посмотреть как бы это работало без дикого оверхеда в виде shared_ptr.

Many C++ classes in Qt use implicit data sharing to maximize resource usage and minimize copying. Implicitly shared classes are both safe and efficient when passed as arguments, because only a pointer to the data is passed around, and the data is copied only if and when a function writes to it, i.e., copy-on-write.

C>Простых? Удобных?

This variance refers to the parameters and return types of an overridden method in a descendant class. C++ supports this for covariance of return types. Return types and out parameters may be covariant, input parameters may be contravariant, and in-out parameters must be invariant. C++ example: ...

"Neither C#, the CLI nor Java support override variance. C++ supports return type override covariance, but not override contravariant input arguments. C++/CLI doesn't support override covariant return types for managed classes. It gives this error:

error C2392: 'Dog ^Dog::GetValue(void)' : covariant returns types are
not supported in managed types, otherwise 'Mammal ^Mammal::GetValue(void)' would be overridden

MX>>После слов "Это конечно здорово, но вот как узнать является ли этот тип каким-либо из элементарных типов, указателем или ссылкой ? Является ли он const или нет ?" этого профана сил осиливать его поток у меня не осталось.

C>Он правду сказал, а Вы классически "съехали на оскорбления", не могучи аргументированно ответить.

GC.Collect();
GC.WaitForPendingFinalizers();

template<typename T, void (T::*m)()>
struct zz
{
    zz()
    {
        T t;
        (t.*m)();
    }
};

MX> M>И что, прямо-таки можно легко сериализовать объект любой сложности?

ar & boost::serialization::base_object<bus_stop>(*this) & name;