Следующие рассуждения в принципе мне кажутся очень простыми, но ни разу их не встречал.

Одна из главных причин, почему C++ плохой язык: для этого надо сначала понять, почему C хороший. В чем состоит то свойство C, из-за которого его называют "портабильным ассемблером"? Дело не в том, что "близко к машине", и всё низкого уровня. Дело в том, что почти всегда в C эффект любой строки кода локален и очевиден. Когда я что-то делаю в C, неважно что, я очень хорошо понимаю, что именно происходит. Если я пишу x=y, я знаю точно, что происходит. Если я пишу f(...), я знаю точно, какая конкретно функция будет вызвана, я могу указать на неё пальцем, и я знаю точно, что произойдёт в момент входа в неё и выхода из неё. Если я выделяю память, я знаю точно, что она не исчезнет, пока я её не освобожу. Итд. итп. Атомарные строки кода переходят в атомарные куски кода во время запуска, и никаких сюрпризов. Есть исключения: например, если я вызываю функцию через ссылку, я не знаю, что собственно я вызвал, до рантайма. Но этих исключений очень мало и они тоже "локализованы" и их легко понять.

Это необязательно хорошо. Но это — в C — выполняется последовательно, и то, что это последовательно — хорошо. Разные языки по-разному решают вопрос о том, как позволить программистам прятать информацию от самих себя. В объектно-ориентированных языках принцип полиморфизма, принципиального незнания мной того, объект какого класса я вызываю по ссылке (базового или наследника), является краеугольным; и это по-своему хорошо, если проведено последовательно.

C++ — смесь разных принципов отношения к информации и средствам её прятать или открывать, которые доступны программисту; смесь, кажется, очень плохо продуманная. С одной стороны, полностью сохранён "низкий уровень" C, в том числе отсутствие сборки мусора, т.е. очень важный пример того, что заставляем программиста за всем следить и обо всём помнить. Множественное наследование — другой пример: если практически оказывается возможным его воплотить, мы его воплощаем, пусть оно концептуально сложно, пусть оно заставляет программиста выслеживать порядок вызова конструкторов, всякие ужасные "ромбики" и прочую хренотень.

Но, с другой стороны: полностью нарушен (я бы сказал, низвергнут с пьедестала и подвержен особо извращенному поруганию) этот самый принцип локальности поведения системы в ответ на строчку моего кода. Я всего лишь объявил переменную какого-то типа, написав "Typename varname;", но эта строчка может привести к вызову неизвестного мне конструктора, а за ним — кода сколь угодно, вообще говоря, сложности. Я всего лишь применяю известный мне оператор к переменной — а он, оказывает, overloaded у этого класса, и черт знает что на самом деле там произойдет. Я всего лишь вышел из функции, что может быть проще, написал }, а в рантайме на самом деле пошли плясать деструкторы всех автоматических объектов в этой функции. И даже и не буду начинать говорить про copy constructor и прочие подобные прелести.

Так вот, поэтому C++ — плохой язык.

Он настолько много прячет за кулисами, чтобы навязать программисту режим работы "моя хата с краю": пиши свой код, не волнуйся насчёт того, что магически происходит вокруг него, всё хорошо, всё идёт по плану... И в то же время того же программиста заставляет следить за всеми malloc()'ами и new, рассчитывать ужасные иерархии наследования и дикие функции-"френды", не говоря уж о темплейтах. По сути дела, медленно и неумолимо превращает программиста в шизофреника.

I>0 баллов. В boost'е отсутствуют предметы первой необходимости. 2-я попытка, пожалуйста.

Smart pointers that provide automatic lifetime management of objects and simplify resource sharing

Consistent, best-practice solutions for performing type conversions and lexical conversions

Utility classes that make programming simpler and clearer

Flexible container libraries that solve common problems not covered by the C++ Standard Library

Powerful support for regular expressions with Boost.Regex

Function objects defined at the call site with Boost.Bind and Boost.Lambda

More flexible callbacks with Boost.Function

Managed signals and slots (a.k.a. the Observer pattern) with Boost.Signals

VG>Smart pointers that provide automatic lifetime management of objects and simplify resource sharing
. . .

1. Расход памяти
2. Расход выч. ресурсов
3. Локаничность кода
4. Удобочитаемость
5. Сопровождаемость
6. Переносимость

PA>А вот Erwin Unruh, Todd Velhuizen и, конечно же, Степанов — это наши. Это они подрывают основы C++-сообщества. Они незаметно внедрили функциональный стиль в большинство программ на C++, чтобы потом C++-ники неожиданно обнаружили, что все это фигня по сравнению с настоящими ФЯ. Вот такой коварный план. Первые жертвы уже есть .

int count=std::count_if(
  ints.begin(), 
  ints.end(), 
  boost::bind(
    std::logical_and<bool>(), 
    boost::bind(std::greater<int>(), _1, 5), 
    boost::bind(std::less_equal<int>(), _1, 10)));

std::cout << count << '\n';

std::vector<int>::iterator int_it=std::find_if(
  ints.begin(), 
  ints.end(), 
  boost::bind(std::logical_and<bool>(), 
    boost::bind(std::greater<int>(), _1, 5), 
    boost::bind(std::less_equal<int>(), _1, 10)));

E>int count=std::count_if(
E>  ints.begin(), 
E>  ints.end(), 
E>  boost::bind(
E>    std::logical_and<bool>(), 
E>    boost::bind(std::greater<int>(), _1, 5), 
E>    boost::bind(std::less_equal<int>(), _1, 10)));

E>std::cout << count << '\n';

E>std::vector<int>::iterator int_it=std::find_if(
E>  ints.begin(), 
E>  ints.end(), 
E>  boost::bind(std::logical_and<bool>(), 
E>    boost::bind(std::greater<int>(), _1, 5), 
E>    boost::bind(std::less_equal<int>(), _1, 10)));

using namespace std;
using namespace boost;

int count=count_if(
  ints.begin(), 
  ints.end(), 
  bind(
    logical_and<bool>(), 
    bind(greater<int>(), _1, 5), 
    bind(less_equal<int>(), _1, 10)));

cout << count << '\n';

vector<int>::iterator int_it=find_if(
  ints.begin(), 
  ints.end(), 
  bind(logical_and<bool>(), 
    bind(greater<int>(), _1, 5), 
    bind(less_equal<int>(), _1, 10)));

I>using namespace std;
I>using namespace boost;

I>int count=count_if(
I>  ints.begin(), 
I>  ints.end(), 
I>  bool lambda( int x ) { return ( 5 < x && x <= 10 ) });

I>cout << count << '\n';

I>vector<int>::iterator int_it=find_if(
I>  ints.begin(), 
I>  ints.end(), 
I>  bool lambda( int x ) { return ( 5 < x && x <= 10 ) });
I>

auto predicat = bool lambda( int x ) { return ( 5 < x && x <= 10 };

int count = count_if( ints.begin(), ints.end(), predicat );
...
auto int_it = find_if( ints.begin(), ints.end(), predicat );

inline f(), #define f()

E>auto predicat = bool lambda( int x ) { return ( 5 < x && x <= 10 };

E>int count = count_if( ints.begin(), ints.end(), predicat );
E>...
E>auto int_it = find_if( ints.begin(), ints.end(), predicat );
E>

int count = 0;
ints.each( { |x| count++ if(5 < x && x <= 10) } );

dmz>int count = 0;
dmz>ints.each( { |x| count++ if(5 < x && x <= 10) } );

Он его ночами крутит, ловит, контра, ФРГ. (C)

int count = 0;
ints.each( { |x| count++ if(5 < x && x <= 10) } );

+/(5<ints)&(~ints>10)

printf("File %s has length=%d\n",file_name,length);

FILE *f=fopen("coolfile.txt");

C++0x Standard Library wishlist (draft revision 6)
. . .
GUI

Requester: Bjarne Stroustrup, Michael Rasmussen, John Medema, others
Paper:

Some form of simple graphic/GUI library (possibly a simple interface to the simpler parts of larger libraries)—a recurent theme.

Some thoughts on this from Michael Rasmussen:
The main architecture resembles the idea behind Java's JDBC. E.g. the language/library provides a standard interface or set of interfaces and developers of graphics libraries does the actual implementation. If put into a design pattern terminology the standard interface is a factory hiding all implementation specific stuff from the programmer. The standard interface would specify features and their dependencies but otherwise leave implementation descessions to the developers of the graphics library.

There are many advantages to this architecture of which I will point out the most important ones:

* Portability: Write one GUI class and reuse it on any platform providing a C++ GUI standards compliant implementation.
* Simplicity: The C++ language does not need to maintain a binary code base on every available platform. All the language needs to maintain is a specification for the interface.
* Compatibility: If the architecture is chosen backwards compatibility can be maintained because the interface will be purely written in standard C++ and have no ties to the underlying platforms graphics specifications and/or hardware.
* Control: No graphics library will be able to extend or change the functionality of the GUI interface in the language. This means that the community will be in full control of the direction and development but at the same time the community will not in any way prevent developers of graphics libraries to go further. A core will be standards compliant and the extention will not be.

It is hard for me to point out some disadvantages but of course one is obvious: The success depends on adaptation from developers of graphics libraries.

X>Сильные умом благосклонны к языкам не напрягающим их сильные умы...

Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн

ИМХО:
— GUI
— GUI
— GUI
...

E>auto predicat = bool lambda( int x ) { return ( 5 < x && x <= 10 };

E>int count = count_if( ints.begin(), ints.end(), predicat );
E>...
E>auto int_it = find_if( ints.begin(), ints.end(), predicat );
E>

def seq = [1, 30, 5, 7, 2, 6, 6];

def countIf(seq, predicate)
{
    seq.FoldLeft(0, fun(x, i){ if (predicate(x)) i + 1 else i });
}

def result = countIf(seq, fun(x){ 5 < x && x <= 10 });
Nemerle.IO.printf("Result: %d\n", result);

Result: 3

 . . .
VD>    seq.FoldLeft(0, fun(x, i){ if (predicate(x)) i + 1 else i });
 . . .

... iterator theories are as central to Computer Science as theories of rings or Banach spaces are central to Mathematics. <i>(Alex Stepanov)</i>

def FoldLeft(collection, mutable value, func)
{
    foreach(element in collection)
    {
        value = func(value, element);
    }
    value
}

def numbers = [1, 2, 3, 4];
def product = FoldLeft(_, 1, fun(product, number) { product * number });
Nemerle.IO.printf("%d\n", product(numbers));

static IEnumerable<T> Repeater<T>(IEnumerable<T> seq)
{
    while (true)
        foreach (T value in seq)
            yield return value;
}

static void Main()
{
    foreach (int value in Repeater(new int[] { 1, 2, 3 }))
        Console.Write(value + " ");
}