J>>>Зато четырех-ядерный спасет .

Дана картинка, известная, Dawn Of Ubuntu 1920x1200x24. Pentium M 1.7. 512 RAM. Все лишнее выгрузил.

1. Paint.NET 3.31. Фильтр Gaussian Blur (200px) — 2мин. 28 сек (148 сек)
2.1. GIMP 2.2.11. Фильтр Гауcсово размывание (200x200px. IRR) — 4сек.
2.2. GIMP 2.2.11. Фильтр Гаусcово размывание (200x200px. RLE) — 20сек.

class a
{
 int i1;
 int i2;
 double d1;
 void save(const char * file)
 {
  int f = open(file, O_CREAT | O_WRONLY);
  write(f, &i1, sizeof(int));
  write(f, &i2, sizeof(int));
  write(f, &d1, sizeof(double));
  close (f);
 }
 void load(std::string file)
 {
  int f = open(file, O_RDONLY);
  read(f, &i1, sizeof(int));
  read(f, &i2, sizeof(int));
  read(f, &d1, sizeof(double));
  close (f);
 }

};
main()
{
 a *c1 = new a();
 c1->i1 = 5;
 c1->i2 = 15;
 c1->d1 = 0,5;
 c1->save("file.dat");
 a *c2 = new a();
 a->load("file.dat");
}

Var

 sw    : TStopwatch;
 s     : String; // юникод
 Index : Integer;

begin

 sw.Start;

 For Index := 1 To 100000 Do
  s := s + 'c1';

 sw.Stop;

 WriteLn('string.append: elapsed ', sw.ElapsedTime, ' (', Length(s), ')');

end.

using System;
using System.Diagnostics;
using System.Text;

class _
{
 static void Main(string[] args)
 {
            var stopwatch = new Stopwatch();
            var s = "";

            stopwatch.Start();

            for (int i = 0; i < 100000; i++)
            {
                s = s + "c1";
            }
            stopwatch.Stop();
            Console.WriteLine("append: elapsed {0}", stopwatch.Elapsed);
 }
}

J>Не замечаю. Что Paint, что янус — ничем не отличаются от нативнго, если конечно не внушатьсебе обратного. Да и WinForms это просто обертка над обычными виндовс-контролами, так что к производительности дотнет-кода оно относится слабо.

J>Наиндусить можно где угодно .

Bitmap Class
Encapsulates a GDI+ bitmap, which consists of the pixel data for a graphics image and its attributes.

J>Что-то я не смог найти исходники paint.net на их сайте . Похоже он больше не open source?

S>class a
S>{
S> int i1;
S> int i2;
S> double d1;
S> void save(const char * file)
S> {
S>  int f = open(file, O_CREAT | O_WRONLY);
S>  write(f, &i1, sizeof(int));
S>  write(f, &i2, sizeof(int));
S>  write(f, &d1, sizeof(double));
S>  close (f);
S> }
S> void load(std::string file)
S> {
S>  int f = open(file, O_RDONLY);
S>  read(f, &i1, sizeof(int));
S>  read(f, &i2, sizeof(int));
S>  read(f, &d1, sizeof(double));
S>  close (f);
S> }

S>};
S>main()
S>{
S> a *c1 = new a();
 c1->>i1 = 5;
 c1->>i2 = 15;
 c1->>d1 = 0,5;
 c1->>save("file.dat");
S> a *c2 = new a();
 a->>load("file.dat");
S>}
S>

S>Но для вас господа. чувствую, это из ряда вон выходящее. Минусуйте, чего уж.

class b : public a
{
  int test;
public:
  void virtual  save(const char * file)
  {
    a::save(file);
    //сохраняем.
  }
  void virtual  load(const char * file)
  {
    a::load(file);
    //загружаем.
  }
};
main()
{
 a *c1 = GetA(); // не знаем реальный класс c1.
 c1->>i1 = 5;
 c1->>i2 = 15;
 c1->>d1 = 0,5;
 c1->>save("file.dat");
 a *c2 = new a(); // соответственно и при загрузке не знаем реальный тип c2.
 a->>load("file.dat");//<- не-не-не Дэвид Блейн

Y>>>StringBuilder sb = new StringBuilder(30 * 1024 * 512, 30 * 1024 * 512);
Y>>>sb.Append('a', 30 * 1024 * 512 /* char = 2 bytes */);
Y>>>

Y>>> где двойной оверхед...

H>>Ну ты молодец, установил максимальную Capacity и мне еще такие вопросы задаешь Коли уж решил проверить, так и проверяй на синтетике которая была дана, а не изобретай свой вариант с ограничительными условиями.

Y>StringBuilder sb = new StringBuilder();
Y>sb.Append('a'); // какой здесь оверхед?
Y>sb.Append('a', 15); // а вот здесь?
Y>sb.Append('a'); // а как насчет здесь?
Y>

using System;
using System.Diagnostics;
using System.Text;

class _
{
 static void Main(string[] args)
 {
            var stopwatch = new Stopwatch();

            stopwatch.Start();
            var stringBuilder = new StringBuilder();

            for (int i = 0; i < 10000000; i++)
            {
                stringBuilder.Append("c1");
            }
            stopwatch.Stop();
            Console.WriteLine("append: elapsed {0}", stopwatch.Elapsed);
            Console.WriteLine(stringBuilder.Length);
        Console.ReadLine(); // первая контрольная точка

            stopwatch.Start();
            stringBuilder.Replace("c1", "abc4");
            stopwatch.Stop();
            Console.WriteLine("replace: elapsed {0}", stopwatch.Elapsed);
            Console.WriteLine(stringBuilder.Length);
        Console.ReadLine(); // вторая контрольная точка

 }
}

Y>Как пользователь, я лично могу сказать что рад, что ATI свой Catalyst Control Center на дотнете переписали, до этого он мне изрядно попортил нервы своими memory leak'ами, когда через несколько дней аптайма сжирал большу часть памяти (если доживал несколько дней, чаще падал гораздо раньше )

H>>Пример с Автокадом скоро достигнет того же уровня замозоленности, что и Paint.NET

Y>Встречал возню с Автокадом только на КЫВТе. Да и тут мозолят эту тему буквально несколько человек . Кстати, от того, что Paint.NET постоянно упоминается в таких обсуждениях, он не перестает быть дотнетовским приложением

H>>Я выделил в первом посте Просто ты, как бы, черту подвел под все высказывания non-.Net'еров/нативщиков. Собственно, только с этим

Из C++ звать код на C — тоже нормально. А вот .Net — не, либо приложение 100% управляемое, либо дотнет ущербен для этого приложения.

nVidia благо такой фигнёй не занимается — у них панель управления native, как полагается.

Как пользователь, я лично могу сказать что рад, что ATI свой Catalyst Control Center на дотнете переписали, до этого он мне изрядно попортил нервы своими memory leak'ами, когда через несколько дней аптайма сжирал большу часть памяти (если доживал несколько дней, чаще падал гораздо раньше )

S>Мда, дотнет явно людям на пользу не идёт

class Base
{
    // ...
    virtual vector<byte> Serialize()=0;
}

class Derived1 : public Base
{
    // ...
    virtual vector<byte> Serialize() 
    {
        // ...
    }
}

class Derived2 : public Base
{
    // ...
    virtual vector<byte> Serialize()
    {
        // ...
    }
}


// Где-то в одном месте программы...
Base* pObj = GetSomeObject();
vector<byte> v = pObj->Serialize();
ЗаписатьБайтыВХранилище(v);


// Где-то в другом месте программы
vector<byte> v = ПолучитьБайтыИзХранилища();
Base* pObj = CreateSomeObject(v);    // <- Вот тут и засада

class C
{
  ...
}

class A
{
  ...
}

class B: public A
{
  private:
    C*  field; //или смарт-поинтер какой-нибудь
  ...
}

A* a = new B(...);
x = serialize(a);
a = /*особая магия десериализации*/(x);