Здравствуйте, коллеги
Вдруг стало интересно, существуюти ли библиотеки для С для работы со списками,
массивами, ассоциатисными массивами и т.д., что-то типа STL, только для С.
Или при написании проги на Сях, каждый раз изобретают все те же велосипеды?
Поиск в google.com & rsdn.ru ничего толкового не дал.
Поделитесь, пожалуйста, линками. Интересуют аналоги variant, list, map.

Здравствуйте, nau, Вы писали:

nau>Здравствуйте, коллеги
nau>Вдруг стало интересно, существуюти ли библиотеки для С для работы со списками,
nau>массивами, ассоциатисными массивами и т.д., что-то типа STL, только для С.
nau>Или при написании проги на Сях, каждый раз изобретают все те же велосипеды?
nau>Поиск в google.com & rsdn.ru ничего толкового не дал.
nau>Поделитесь, пожалуйста, линками. Интересуют аналоги variant, list, map.
Прошу прощения, конечно же, vector

nau wrote:

> Вдруг стало интересно, существуюти ли библиотеки для С для работы со
> списками,
> массивами, ассоциатисными массивами и т.д., что-то типа STL, только
> для С.

Есть GLib (основная библиотека в GNOME, она кроссплатформенная) — там
достаточно неплохая библиотека работы с контейнерами. Есть еще несколько
макросных библиотек контейнеров (в Netscape Portable Runtime, кажется,
есть одна).

--
С уважением,
Alex Besogonov (alexy@izh.com)

C>Есть GLib (основная библиотека в GNOME, она кроссплатформенная) — там
C>достаточно неплохая библиотека работы с контейнерами. Есть еще несколько
C>макросных библиотек контейнеров (в Netscape Portable Runtime, кажется,
C>есть одна).

И это все? Неужели все заново пишут те же велосипеды? Или же многие пользуют Glib?
Скажите, пожалуйста, кто что использует.

nau wrote:

> C>Есть GLib (основная библиотека в GNOME, она кроссплатформенная) — там
> C>достаточно неплохая библиотека работы с контейнерами. Есть еще
> несколько
> C>макросных библиотек контейнеров (в Netscape Portable Runtime, кажется,
> C>есть одна).
> И это все? Неужели все заново пишут те же велосипеды? Или же многие
> пользуют Glib?
> Скажите, пожалуйста, кто что использует.

В Glib вроде все нужное есть. У меня еще была своя макросная библиотека
для списков и векторов, только я ее давным-давно уже потерял после краха
винчестера.

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, nau, Вы писали:

nau>Здравствуйте, коллеги
nau>Вдруг стало интересно, существуюти ли библиотеки для С для работы со списками,
nau>массивами, ассоциатисными массивами и т.д., что-то типа STL, только для С.
nau>Или при написании проги на Сях, каждый раз изобретают все те же велосипеды?
nau>Поиск в google.com & rsdn.ru ничего толкового не дал.
nau>Поделитесь, пожалуйста, линками. Интересуют аналоги variant, list, map.

Apache Portable Runtime:
— Hash tables;
— Table and Array Functions;

eao197 wrote:

> nau>Вдруг стало интересно, существуюти ли библиотеки для С для работы
> со списками,
> nau>массивами, ассоциатисными массивами и т.д., что-то типа STL,
> только для С.
> nau>Или при написании проги на Сях, каждый раз изобретают все те же
> велосипеды?
> nau>Поиск в google.com & rsdn.ru ничего толкового не дал.
> nau>Поделитесь, пожалуйста, линками. Интересуют аналоги variant, list,
> map.
> Apache Portable Runtime <http://apr.apache.org>:

Угу, про APR забыл. Хотя у него есть большой минус — он привязан к
апачевской системе пулов для управления памятью. В этом отношении GLib
лучше.

> — Hash tables <http://apr.apache.org/docs/apr/group__apr__hash.html&gt;;

http://sourceforge.net/projects/goog-sparsehash/ — Sparse Hashtable от
Гугла

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, Cyberax, Вы писали:

C>nau wrote:
о что использует.

C>В Glib вроде все нужное есть. У меня еще была своя макросная библиотека
C>для списков и векторов, только я ее давным-давно уже потерял после краха
C>винчестера.
фи

LuciferMoscow wrote:

> C>nau wrote:
> о что использует.

То есть? Не понял смысла фразы.

> C>В Glib вроде все нужное есть. У меня еще была своя *макросная*
> библиотека
> C>для списков и векторов, только я ее давным-давно уже потерял после
> краха
> C>винчестера.
> фи

Предложите лучший вариант типобезопасных контейнеров для языка C.

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, Cyberax, Вы писали:

C>Предложите лучший вариант типобезопасных контейнеров для языка C.
На голых Сях пас.

P.S. "фи" снимается
P.S.S. Как говорил проф. Преображенский

Макросы — они как педикулез. От бедности.

Здравствуйте, LuciferMoscow, Вы писали:

C>>В Glib вроде все нужное есть. У меня еще была своя макросная библиотека
C>>для списков и векторов, только я ее давным-давно уже потерял после краха
C>>винчестера.
LM>фи



Извини, а можно спросить, как ты иначе представляешь себе обобщенный контейнер на C?

LM>

LM>Макросы — они как педикулез. От бедности.

Не согласен. Си — это язык. И о его "бедности" рассуждать не надо.

Здравствуйте, _Winnie, Вы писали:

_W>Здравствуйте, LuciferMoscow, Вы писали:

C>>>В Glib вроде все нужное есть. У меня еще была своя макросная библиотека
C>>>для списков и векторов, только я ее давным-давно уже потерял после краха
C>>>винчестера.
LM>>фи
_W>Извини, а можно спросить, как ты иначе представляешь себе обобщенный контейнер на C?
Извини, но на голых Сях не писал. С++

APR не лишено недостатков, но присуствуют и достоинства.

а так.. ну макросы...

#ifndef    _queue_h_
#define    _queue_h_

#ifdef __cplusplus
extern "C" {
#endif

#undef SLIST_HEAD
#undef SLIST_HEAD_INITIALIZER
#undef SLIST_ENTRY
#undef SLIST_FIRST
#undef SLIST_END
#undef SLIST_EMPTY
#undef SLIST_NEXT
#undef SLIST_FOREACH
#undef SLIST_INIT
#undef SLIST_INSERT_AFTER
#undef SLIST_INSERT_HEAD
#undef SLIST_REMOVE_HEAD
#undef SLIST_REMOVE
#undef LIST_HEAD
#undef LIST_HEAD_INITIALIZER
#undef LIST_ENTRY
#undef LIST_FIRST
#undef LIST_END
#undef LIST_EMPTY
#undef LIST_NEXT
#undef LIST_FOREACH
#undef LIST_INIT
#undef LIST_INSERT_AFTER
#undef LIST_INSERT_BEFORE
#undef LIST_INSERT_HEAD
#undef LIST_REMOVE
#undef LIST_REPLACE
#undef SIMPLEQ_HEAD
#undef SIMPLEQ_HEAD_INITIALIZER
#undef SIMPLEQ_ENTRY
#undef SIMPLEQ_FIRST
#undef SIMPLEQ_END
#undef SIMPLEQ_EMPTY
#undef SIMPLEQ_NEXT
#undef SIMPLEQ_FOREACH
#undef SIMPLEQ_INIT
#undef SIMPLEQ_INSERT_HEAD
#undef SIMPLEQ_INSERT_TAIL
#undef SIMPLEQ_INSERT_AFTER
#undef SIMPLEQ_REMOVE_HEAD
#undef TAILQ_HEAD
#undef TAILQ_HEAD_INITIALIZER
#undef TAILQ_ENTRY
#undef TAILQ_FIRST
#undef TAILQ_END
#undef TAILQ_NEXT
#undef TAILQ_LAST
#undef TAILQ_PREV
#undef TAILQ_EMPTY
#undef TAILQ_FOREACH
#undef TAILQ_FOREACH_REVERSE
#undef TAILQ_INIT
#undef TAILQ_INSERT_HEAD
#undef TAILQ_INSERT_TAIL
#undef TAILQ_INSERT_AFTER
#undef TAILQ_INSERT_BEFORE
#undef TAILQ_REMOVE
#undef TAILQ_REPLACE
#undef CIRCLEQ_HEAD
#undef CIRCLEQ_HEAD_INITIALIZER
#undef CIRCLEQ_ENTRY
#undef CIRCLEQ_FIRST
#undef CIRCLEQ_LAST
#undef CIRCLEQ_END
#undef CIRCLEQ_NEXT
#undef CIRCLEQ_PREV
#undef CIRCLEQ_EMPTY
#undef CIRCLEQ_FOREACH
#undef CIRCLEQ_FOREACH_REVERSE
#undef CIRCLEQ_INIT
#undef CIRCLEQ_INSERT_AFTER
#undef CIRCLEQ_INSERT_BEFORE
#undef CIRCLEQ_INSERT_HEAD
#undef CIRCLEQ_INSERT_TAIL
#undef CIRCLEQ_REMOVE
#undef CIRCLEQ_REPLACE

    /*
    * Singly-linked List declarations.
    */
#define    SLIST_HEAD(name, type)                        \
    struct name {                                \
    struct type *slh_first;    /* first element */            \
    }

#define    SLIST_HEAD_INITIALIZER(head)                    \
    { NULL }

#define    SLIST_ENTRY(type)                        \
    struct {                                \
    struct type *sle_next;    /* next element */            \
    }

    /*
    * Singly-linked List functions.
    */
#define    SLIST_EMPTY(head)    ((head)->slh_first == NULL)

#define    SLIST_FIRST(head)    ((head)->slh_first)

#define    SLIST_FOREACH(var, head, field)                    \
    for ((var) = SLIST_FIRST((head));                \
    (var);                            \
    (var) = SLIST_NEXT((var), field))

#define    SLIST_FOREACH_SAFE(var, head, field, tvar)            \
    for ((var) = SLIST_FIRST((head));                \
    (var) && ((tvar) = SLIST_NEXT((var), field), 1);        \
    (var) = (tvar))

#define    SLIST_FOREACH_PREVPTR(var, varp, head, field)            \
    for ((varp) = &SLIST_FIRST((head));                \
    ((var) = *(varp)) != NULL;                    \
    (varp) = &SLIST_NEXT((var), field))

#define    SLIST_INIT(head) do {                        \
    SLIST_FIRST((head)) = NULL;                    \
} while (0)

#define    SLIST_INSERT_AFTER(slistelm, elm, field) do {            \
    SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);    \
    SLIST_NEXT((slistelm), field) = (elm);                \
} while (0)

#define    SLIST_INSERT_HEAD(head, elm, field) do {            \
    SLIST_NEXT((elm), field) = SLIST_FIRST((head));            \
    SLIST_FIRST((head)) = (elm);                    \
} while (0)

#define    SLIST_NEXT(elm, field)    ((elm)->field.sle_next)

#define    SLIST_REMOVE(head, elm, type, field) do {            \
    if (SLIST_FIRST((head)) == (elm)) {                \
    SLIST_REMOVE_HEAD((head), field);            \
    }                                \
    else {                                \
    struct type *curelm = SLIST_FIRST((head));        \
    while (SLIST_NEXT(curelm, field) != (elm))        \
    curelm = SLIST_NEXT(curelm, field);        \
    SLIST_NEXT(curelm, field) =                \
    SLIST_NEXT(SLIST_NEXT(curelm, field), field);    \
}                                \
} while (0)

#define    SLIST_REMOVE_HEAD(head, field) do {                \
    SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);    \
} while (0)

    /*
    * Singly-linked Tail queue declarations.
    */
#define    STAILQ_HEAD(name, type)                        \
    struct name {                                \
    struct type *stqh_first;/* first element */            \
    struct type **stqh_last;/* addr of last next element */        \
    }

#define    STAILQ_HEAD_INITIALIZER(head)                    \
    { NULL, &(head).stqh_first }

#define    STAILQ_ENTRY(type)                        \
    struct {                                \
    struct type *stqe_next;    /* next element */            \
    }

    /*
    * Singly-linked Tail queue functions.
    */
#define    STAILQ_CONCAT(head1, head2) do {                \
    if (!STAILQ_EMPTY((head2))) {                    \
    *(head1)->stqh_last = (head2)->stqh_first;        \
    (head1)->stqh_last = (head2)->stqh_last;        \
    STAILQ_INIT((head2));                    \
    }                                \
} while (0)

#define    STAILQ_EMPTY(head)    ((head)->stqh_first == NULL)

#define    STAILQ_FIRST(head)    ((head)->stqh_first)

#define    STAILQ_FOREACH(var, head, field)                \
    for((var) = STAILQ_FIRST((head));                \
    (var);                            \
    (var) = STAILQ_NEXT((var), field))


#define    STAILQ_FOREACH_SAFE(var, head, field, tvar)            \
    for ((var) = STAILQ_FIRST((head));                \
    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);        \
    (var) = (tvar))

#define    STAILQ_INIT(head) do {                        \
    STAILQ_FIRST((head)) = NULL;                    \
    (head)->stqh_last = &STAILQ_FIRST((head));            \
} while (0)

#define    STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {        \
    if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
    (head)->stqh_last = &STAILQ_NEXT((elm), field);        \
    STAILQ_NEXT((tqelm), field) = (elm);                \
} while (0)

#define    STAILQ_INSERT_HEAD(head, elm, field) do {            \
    if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)    \
    (head)->stqh_last = &STAILQ_NEXT((elm), field);        \
    STAILQ_FIRST((head)) = (elm);                    \
} while (0)

#define    STAILQ_INSERT_TAIL(head, elm, field) do {            \
    STAILQ_NEXT((elm), field) = NULL;                \
    *(head)->stqh_last = (elm);                    \
    (head)->stqh_last = &STAILQ_NEXT((elm), field);            \
} while (0)

#define    STAILQ_LAST(head, type, field)                    \
    (STAILQ_EMPTY((head)) ?                        \
NULL :                            \
    ((struct type *)                    \
    ((char *)((head)->stqh_last) - __offsetof(struct type, field))))

#define    STAILQ_NEXT(elm, field)    ((elm)->field.stqe_next)

#define    STAILQ_REMOVE(head, elm, type, field) do {            \
    if (STAILQ_FIRST((head)) == (elm)) {                \
    STAILQ_REMOVE_HEAD((head), field);            \
    }                                \
    else {                                \
    struct type *curelm = STAILQ_FIRST((head));        \
    while (STAILQ_NEXT(curelm, field) != (elm))        \
    curelm = STAILQ_NEXT(curelm, field);        \
    if ((STAILQ_NEXT(curelm, field) =            \
    STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
    (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
}                                \
} while (0)

#define    STAILQ_REMOVE_HEAD(head, field) do {                \
    if ((STAILQ_FIRST((head)) =                    \
    STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)        \
    (head)->stqh_last = &STAILQ_FIRST((head));        \
} while (0)

#define    STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {            \
    if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL)    \
    (head)->stqh_last = &STAILQ_FIRST((head));        \
} while (0)

    /*
    * List declarations.
    */
#define    LIST_HEAD(name, type)                        \
    struct name {                                \
    struct type *lh_first;    /* first element */            \
    }

#define    LIST_HEAD_INITIALIZER(head)                    \
    { NULL }

#define    LIST_ENTRY(type)                        \
    struct {                                \
    struct type *le_next;    /* next element */            \
    struct type **le_prev;    /* address of previous next element */    \
    }

    /*
    * List functions.
    */

#define    LIST_EMPTY(head)    ((head)->lh_first == NULL)

#define    LIST_FIRST(head)    ((head)->lh_first)

#define    LIST_FOREACH(var, head, field)                    \
    for ((var) = LIST_FIRST((head));                \
    (var);                            \
    (var) = LIST_NEXT((var), field))

#define    LIST_FOREACH_SAFE(var, head, field, tvar)            \
    for ((var) = LIST_FIRST((head));                \
    (var) && ((tvar) = LIST_NEXT((var), field), 1);        \
    (var) = (tvar))

#define    LIST_INIT(head) do {                        \
    LIST_FIRST((head)) = NULL;                    \
} while (0)

#define    LIST_INSERT_AFTER(listelm, elm, field) do {            \
    if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
    LIST_NEXT((listelm), field)->field.le_prev =        \
    &LIST_NEXT((elm), field);                \
    LIST_NEXT((listelm), field) = (elm);                \
    (elm)->field.le_prev = &LIST_NEXT((listelm), field);        \
} while (0)

#define    LIST_INSERT_BEFORE(listelm, elm, field) do {            \
    (elm)->field.le_prev = (listelm)->field.le_prev;        \
    LIST_NEXT((elm), field) = (listelm);                \
    *(listelm)->field.le_prev = (elm);                \
    (listelm)->field.le_prev = &LIST_NEXT((elm), field);        \
} while (0)

#define    LIST_INSERT_HEAD(head, elm, field) do {                \
    if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)    \
    LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
    LIST_FIRST((head)) = (elm);                    \
    (elm)->field.le_prev = &LIST_FIRST((head));            \
} while (0)

#define    LIST_NEXT(elm, field)    ((elm)->field.le_next)

#define    LIST_REMOVE(elm, field) do {                    \
    if (LIST_NEXT((elm), field) != NULL)                \
    LIST_NEXT((elm), field)->field.le_prev =         \
    (elm)->field.le_prev;                \
    *(elm)->field.le_prev = LIST_NEXT((elm), field);        \
} while (0)

    /*
    * Tail queue declarations.
    */
#define    TAILQ_HEAD(name, type)                        \
    struct name {                                \
    struct type *tqh_first;    /* first element */            \
    struct type **tqh_last;    /* addr of last next element */        \
    TRACEBUF                            \
    }

#define    TAILQ_HEAD_INITIALIZER(head)                    \
    { NULL, &(head).tqh_first }

#define    TAILQ_ENTRY(type)                        \
    struct {                                \
    struct type *tqe_next;    /* next element */            \
    struct type **tqe_prev;    /* address of previous next element */    \
    TRACEBUF                            \
    }

    /*
    * Tail queue functions.
    */
#define    TAILQ_CONCAT(head1, head2, field) do {                \
    if (!TAILQ_EMPTY(head2)) {                    \
    *(head1)->tqh_last = (head2)->tqh_first;        \
    (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;    \
    (head1)->tqh_last = (head2)->tqh_last;            \
    TAILQ_INIT((head2));                    \
    QMD_TRACE_HEAD(head1);                    \
    QMD_TRACE_HEAD(head2);                    \
    }                                \
} while (0)

#define    TAILQ_EMPTY(head)    ((head)->tqh_first == NULL)

#define    TAILQ_FIRST(head)    ((head)->tqh_first)

#define    TAILQ_FOREACH(var, head, field)                    \
    for ((var) = TAILQ_FIRST((head));                \
    (var);                            \
    (var) = TAILQ_NEXT((var), field))

#define    TAILQ_FOREACH_SAFE(var, head, field, tvar)            \
    for ((var) = TAILQ_FIRST((head));                \
    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
    (var) = (tvar))

#define    TAILQ_FOREACH_REVERSE(var, head, headname, field)        \
    for ((var) = TAILQ_LAST((head), headname);            \
    (var);                            \
    (var) = TAILQ_PREV((var), headname, field))

#define    TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
    for ((var) = TAILQ_LAST((head), headname);            \
    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);    \
    (var) = (tvar))

#define    TAILQ_INIT(head) do {                        \
    TAILQ_FIRST((head)) = NULL;                    \
    (head)->tqh_last = &TAILQ_FIRST((head));            \
    QMD_TRACE_HEAD(head);                        \
} while (0)

#define    TAILQ_INSERT_AFTER(head, listelm, elm, field) do {        \
    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
    TAILQ_NEXT((elm), field)->field.tqe_prev =         \
    &TAILQ_NEXT((elm), field);                \
    else {                                \
    (head)->tqh_last = &TAILQ_NEXT((elm), field);        \
    QMD_TRACE_HEAD(head);                    \
}                                \
    TAILQ_NEXT((listelm), field) = (elm);                \
    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);        \
    QMD_TRACE_ELEM(&(elm)->field);                    \
    QMD_TRACE_ELEM(&listelm->field);                \
} while (0)

#define    TAILQ_INSERT_BEFORE(listelm, elm, field) do {            \
    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;        \
    TAILQ_NEXT((elm), field) = (listelm);                \
    *(listelm)->field.tqe_prev = (elm);                \
    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);        \
    QMD_TRACE_ELEM(&(elm)->field);                    \
    QMD_TRACE_ELEM(&listelm->field);                \
} while (0)

#define    TAILQ_INSERT_HEAD(head, elm, field) do {            \
    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)    \
    TAILQ_FIRST((head))->field.tqe_prev =            \
    &TAILQ_NEXT((elm), field);                \
    else                                \
    (head)->tqh_last = &TAILQ_NEXT((elm), field);        \
    TAILQ_FIRST((head)) = (elm);                    \
    (elm)->field.tqe_prev = &TAILQ_FIRST((head));            \
    QMD_TRACE_HEAD(head);                        \
    QMD_TRACE_ELEM(&(elm)->field);                    \
} while (0)

#define    TAILQ_INSERT_TAIL(head, elm, field) do {            \
    TAILQ_NEXT((elm), field) = NULL;                \
    (elm)->field.tqe_prev = (head)->tqh_last;            \
    *(head)->tqh_last = (elm);                    \
    (head)->tqh_last = &TAILQ_NEXT((elm), field);            \
    QMD_TRACE_HEAD(head);                        \
    QMD_TRACE_ELEM(&(elm)->field);                    \
} while (0)

#define    TAILQ_LAST(head, headname)                    \
    (*(((struct headname *)((head)->tqh_last))->tqh_last))

#define    TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)

#define    TAILQ_PREV(elm, headname, field)                \
    (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

#define    TAILQ_REMOVE(head, elm, field) do {                \
    if ((TAILQ_NEXT((elm), field)) != NULL)                \
    TAILQ_NEXT((elm), field)->field.tqe_prev =         \
    (elm)->field.tqe_prev;                \
    else {                                \
    (head)->tqh_last = (elm)->field.tqe_prev;        \
    QMD_TRACE_HEAD(head);                    \
}                                \
    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);        \
    TRASHIT((elm)->field.tqe_next);                    \
    TRASHIT((elm)->field.tqe_prev);                    \
    QMD_TRACE_ELEM(&(elm)->field);                    \
} while (0)


#ifdef __cplusplus
}
#endif

#endif    /* !_queue_h_ */

MS>Не согласен. Си — это язык. И о его "бедности" рассуждать не надо.
Почему не надо? У нас же демократия вроде бы . Если брать в рассчёт только синтаксис — то С очень старый и очень бедный язык. И С++ — тоже бедный язык, хоть и побогаче C.
Другое дело что язык — это не только синтаксис, а ещё и куча всего вокруг него — библиотеки, средства разработки, комьюнити и литература, нацеленность языка на те или иные платформы, и прочая, прочая... И во многих нишах и С++ и даже С ещё очень долго не сдадут свои позиции.