sergiotaborda:
O que significa "completa" ? Sem responder a isto a pergunta é vazia.
Se o C++ ultima versão tem um monte de recursos novos é porque copiou de outras ( o pai aprender com os filhos). Lambdas , inferencias de tipos, enums, modelo multithread, threadlocal, tuplas e regex - para citar algumas, não são coisas novas. Se vc for ver em scala ou C#, vc tem as mesmas coisas. Portanto, C++ não é a mais completa, simplesmente porque existem outras tão completas quanto.
Os detalhes que matam. Em C++ e C# enuns são inteiros difarçados. Isto não é OO de verdade. É gambe. Deveria-se chamar "Named Ints" e não "enum". Em java enums são objetos de verdade. São classes que vc pode criar métodos, implementar interfaces, etc...
Java não tem tuplas. Ok. E quem precisa disso ? Milhões de projetos de java e não ha uma API de tuplas .. e daí ? tem coisas que são modismos mais do que necessidade.
Lambdas , java não tem ainda (só no java8) , mas groovy, scala, e um monte de outras linguagens que correm na jvm têm. Se vc precisa muito disso, use. E mais, java não tem lambdas, mas tem a mesma funcionalidade com inner classe. Tudo bem que é mais verboraico e tal, mas é a mesma coisa. Funciona do mesmo jeito. é só porque o pessoal é preguiçoso de usar o que tem.
Scala tem um mecanismo de generics que é absurdamente completo e complexo mais do que qualquer outro. C++ nem tem isso. Ele tem templates, que é um negocio diferente de generics. Java tem type erasure, mas outras linguagens da jvm não. E assim vai.
Então, ser completo ou nao é meio ambiguo porque todas as lingaugens que valem alguma coisa hoje em dia meio que fazem o mesmo. A questão é com que facilidade e como é a API que as acompanha. Scala é muito bom para coisas matemáticas porque permite criar mecanismos de herança para usar com generics e definir operadores (não como no groovy onde vc tem overriding dos operadores já previamente definidos). Não admira que muitos bancos e financeiras lá fora comecem a usar scala. Além disso ela é feita para escalar facilmente e isso em finanças é importante. E não só em finanças , em todo o lugar onde modelos matemáricos seja relevantes. C++ é muito ruim para matemática. Ele não garante que uma mesma conta feita em máquinas diferentes dê o mesmo resultaod , scala, através do java, garante. Podemos até dizer que o scala é novo fortran. Só não é mais porque matrizes não são tipo padrão do scala ,e e vai dai, nunca serão em nenhuma linguagem OO.
O ideia seria ter uma linguaem com o melhor de cada uma. Mas ainda estamos numa fase de entender o que é "melhor". Mais prático nem sempre é melhor.
O forte da c++ é a flexibilidade de ser multiparadigma. A questão da metodologia e qualidade de código não está totalmente relacionada com a linguagem mas com o programador. Por exempĺo o código fonte linux consegue chegar a algo próximo ao paradigma OO usando uma linguagem estruturada como a c. A linguagem vala nada mais é que macros da linguagem c que expandem seu código nessa linguagem e são posteriormente compiladas pelo gcc.
Um exemplo:
using GLib;
class Teste: Object{
public static void main(string[] args){
stdout.printf("Testando.....123");
}
}
Expande:
* teste.c generated by valac 0.18.0, the Vala compiler
* generated from teste.vala, do not modify */
#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define TYPE_TESTE (teste_get_type ())
#define TESTE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TESTE, Teste))
#define TESTE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TESTE, TesteClass))
#define IS_TESTE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TESTE))
#define IS_TESTE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TESTE))
#define TESTE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TESTE, TesteClass))
typedef struct _Teste Teste;
typedef struct _TesteClass TesteClass;
typedef struct _TestePrivate TestePrivate;
struct _Teste {
GObject parent_instance;
TestePrivate * priv;
};
struct _TesteClass {
GObjectClass parent_class;
};
static gpointer teste_parent_class = NULL;
GType teste_get_type (void) G_GNUC_CONST;
enum {
TESTE_DUMMY_PROPERTY
};
void teste_main (gchar** args, int args_length1);
Teste* teste_new (void);
Teste* teste_construct (GType object_type);
void teste_main (gchar** args, int args_length1) {
FILE* _tmp0_;
_tmp0_ = stdout;
fprintf (_tmp0_, "Testando.....123");
}
int main (int argc, char ** argv) {
g_type_init ();
teste_main (argv, argc);
return 0;
}
Teste* teste_construct (GType object_type) {
Teste * self = NULL;
self = (Teste*) g_object_new (object_type, NULL);
return self;
}
Teste* teste_new (void) {
return teste_construct (TYPE_TESTE);
}
static void teste_class_init (TesteClass * klass) {
teste_parent_class = g_type_class_peek_parent (klass);
}
static void teste_instance_init (Teste * self) {
}
GType teste_get_type (void) {
static volatile gsize teste_type_id__volatile = 0;
if (g_once_init_enter (&teste_type_id__volatile)) {
static const GTypeInfo g_define_type_info = { sizeof (TesteClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) teste_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Teste), 0, (GInstanceInitFunc) teste_instance_init, NULL };
GType teste_type_id;
teste_type_id = g_type_register_static (G_TYPE_OBJECT, "Teste", &g_define_type_info, 0);
g_once_init_leave (&teste_type_id__volatile, teste_type_id);
}
return teste_type_id__volatile;
}
Esse código c já possui coletor de lixo e diversas funcionalidades que um programa java teria com a jvm. A vantagem é que ele não tem uma dependência grande como uma vm instalada na máquina. Já é o padrão para desenvolvimento na Fundação Gnome.
Para mim essa é uma das melhores linguagens que já vi. Ela possui todas essas funcionalidades citadas e recursos funcionais como lambdas etc.
Vale a pena ler um artigo sobre ela
https://live.gnome.org/Vala/Tutorial
