D (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
D
D Programming Language logo.svg
Paradigma
Surgido em 1999 (22–23 anos)
Última versão 2.098.0 (10 de outubro de 2021; há 9 meses[1])
Criado por
Estilo de tipagem
  • forte
  • estática
Principais implementações
Influenciada por
Extensão do arquivo: .d
Página oficial dlang.org

D é uma linguagem de programação de uso geral projetada por Walter Bright da Digital Mars. É baseada majoritariamente em C++, apesar de não ser apenas uma variante. A versão estável da primeira especificação (v1.0) foi lançada em janeiro de 2007. O código D nativo é geralmente tão rápido quanto o código C ++ equivalente, embora seja mais curto e economize memória .

Histórico[editar | editar código-fonte]

A linguagem D foi criada por Walter Bright, desenvolvedor de compiladores para as linguagens C e C++ e fundador da Digital Mars. Ela foi concebida em dezembro de 1999 para ser uma sucessora das linguagens C e C++.

É uma linguagem de programação de sistemas, focada em combinar o alto desempenho das linguagens C e C++ com a produtividade de outras linguagens modernas, tais como Ruby e Python.

Características[editar | editar código-fonte]

A linguagem D apresenta, dentre outras características:

  • Fortemente tipada estaticamente;
  • Compilada para código nativo;
  • Multiparadigma: suporta os estilos imperativo, orientado a objetos e multiprogramação de template;
  • Projetada para a orientação a objetos e programação genérica;
  • Pertencente à família com sintaxe semelhante à Linguagem C, com aparência próxima à Linguagem C++ (Compatibilidade com códigos objeto C);
  • Arranjos dinâmicos e associativos;
  • Presença de coletor de lixo;
  • inline Assembler.

Principais metas de D[editar | editar código-fonte]

  • Reduzir os custos de desenvolvimento de software em ao menos 10% com adição de produtividade comprovada, realçando características e ajustando características da linguagem de modo que erros comuns e bugs, que consomem tempo, sejam eliminados;
  • Torná-la fácil para escrever código que seja portável de compilador para compilador, máquina para máquina, e sistema operacional para sistema operacional;
  • Suportar multi-paradigmas de programação, isto é, com um mínimo de suporte a paradigmas imperativos, estruturados, orientados a objetos, e programação genérica;
  • Ter uma curta linha de aprendizagem para programadores acostumados com programação em C ou C++;
  • Tornar D substancialmente mais fácil para implementar um compilador próprio que C++;
  • Ser compatível com as APIs C locais;
  • Ter uma gramática livre de contexto;
  • Incorporar metodologia de Programação de Contrato e teste de unidade;
  • Ser capaz de construir programas leves por si próprio;
  • Reduzir os custos da criação de documentação.

Exemplos de Códigos[editar | editar código-fonte]

Olá Mundo[editar | editar código-fonte]

Ver artigo principal: Programa Olá Mundo
import std.stdio;

void main()
{
   writefln("Olá, Mundo!");
}

ou, equivalente:

import core.stdc.stdio;

void main()
{
   printf("Olá, Mundo!\n");
}

N-Primeiros Números Perfeitos[editar | editar código-fonte]

/*
Para compilar:
rdmd NumerosPerfeitos.d
* /

import core.stdc.stdio;

void main(char[][] args)
{
    int n; // n primeiros números perfeitos
    int num = 0;
    int soma;
    int contador = 0;

    printf( "Entre com o valor de 'N': ");
    scanf("%d", &n);

    printf( "\nOs N primeiros numeros perfeitos sao:\n");

    do
    {
        num += 1;
        soma = 0;
        for ( int i=1; i <= num-1 ; i++ )
        {
            if( (num % i) == 0 )
            {
                soma += i;
            }
        }
        if ( soma == num )
        {
            printf("%d\n", soma);
            contador += 1;
        }
    }while (contador != n);
}

/*
NÚMEROS PERFEITOS
- Um número se diz perfeito se é igual a soma de seus divisores próprios.
- Divisores próprios de um número positivo N são todos os divisores inteiros positivos de N exceto o próprio N.');
- Por exemplo, o número 6, seus divisores próprios são 1, 2 e 3, cuja soma = 6 (1 + 2 + 3 = 6);
  Outro exemplo é o número 28, cujos divisores próprios são 1, 2, 4, 7 e 14, e a soma dos seus divisores próprios
  é 28 (1 + 2 + 4 + 7 + 14 = 28)
* /

Classes[editar | editar código-fonte]

class A
{
   public this() //Construtor
   {
      x = 10.0 + 7i;
   }

   private cfloat x; //número complexo
}

class B : A
{
   public this()
   {
      super(); //Chama o construtor da classe pai
   }
}

Arrays[editar | editar código-fonte]

//Arranjos dinâmicos:
int[] a;
a.length = 10; //comprimento igual a 10 posições
a = 50; //a[0], a[1] ... a[9]= 50
a ~= 48; //adiciona uma posição ao array e atribui 48 a ela

int[] b;
for(int i=0; i<30; i++)
{
   b ~= i;
}

int[] c;
c = b[1..10]; //c[0]= b[1], c[1] =b[2] ... c[8]= b[9]

int[] d;
d = a ~ c; // d[0]=a[0],d[1]=a[1]...,d[10]=a[10],d[11]=c[0]... d[19]=c[8]

int* p = b.ptr; //p aponta para o primeiro elemento de b
for(int i = 0; i < b.length; i++)
   printf("%d\n", *(p+i));

c.sort; //ordena o vetor c
//Arranjos associativos:
int[char[]] a; //array associativo
a["hello"] = 4;
a["tchau"] = 10;
a["oi"] = 50;
a["nome"] = 70;

int* p;
p = ("tchau" in a); //p aponta para uma chave de índice "tchau" e se ela
                   //não existir, p será igual a null
if(p != null) //encontrou o índice
{
   printf("%d\n", *p);
}

a.remove("oi"); //remove a chave "oi"
uint toHash(char[] str)
{
   uint hash;
   foreach (char c; str)
      hash = (hash * 9) + c;
   return hash;
}

é o mesmo que

uint toHash(char[] str)
{
   uint hash;
   for(int i=0; i<str.length; i++)
   {
      char c = str[i];
      hash = (hash * 9) + c;
   }
   return hash;
}

Ver também[editar | editar código-fonte]

Referências

  1. Michael Parker (10 de outubro de 2021). «Change Log: 2.098.0». dlang.org (em inglês). Consultado em 16 de outubro de 2021 
  2. Cade Metz (7 de julho de 2014). «The Next Big Programming Language You've Never Heard Of». Wired (em inglês). Condé Nast Publications 
  3. «DMD - D». wiki.dlang.org (em inglês). 25 de janeiro de 2018. Consultado em 16 de outubro de 2021 
  4. «GDC - D». wiki.dlang.org (em inglês). 23 de agosto de 2021. Consultado em 16 de outubro de 2021 
  5. «GCC Front Ends». gcc.gnu.org (em inglês). 28 de julho de 2021. Consultado em 16 de outubro de 2021 
  6. «LDC - D». wiki.dlang.org (em inglês). 26 de setembro de 2021. Consultado em 16 de outubro de 2021 

Ligações externas[editar | editar código-fonte]