Comparação de ALGOL 68 e C ++ - Comparison of ALGOL 68 and C++

Fatores de comparação
de linguagens de programação
Comparação de
línguas individuais

C ++ não tem:

ALGOL 68 não tem:

Comparação dos operadores de atribuição e igualdade

Intenção ALGOL 68 C ++
Defina uma constante int x=888; const int x = 888;
Inicializar uma variável int x:=888; int x = 888;
Atribuir um valor 888 a uma variável x x:=888; x = 888;
Compare dois valores if x = 888 then ... fi if (x == 888) { ... }
Alocar uma variável do heap ref int x = heap int;
ou simplesmente:
heap int x; 		int* x = new int;
Compare o endereço de dois ponteiros ref int x, y;
if x :=: y then ... fi		 int* x; int* y;

if (x == y) { ... }

Compare o valor referenciado por dois ponteiros ref int x, y;
if x = y then ... fi 		int* x; int* y;

if (*x == *y) { ... }

Nomeie um novo tipo mode longreal = long real; typedef double longreal;
ou (a partir de C ++ 11):
using longreal = double;
Nomeie um novo tipo de registro mode cust = struct(string name, address); struct cust { std::string name, address; };
Nomeie um novo tipo de sindicato mode taggedu = union(string s, real r); union u { std::string s; float f; };
Nomeie um procedimento ou função proc f = (real x) real: ( code; result ); float f(float x) { code; return result; }
Parâmetros padrão do procedimento proc p = (union (real, void) in x)void:

    ( real x = (in x|(real x):x|888); code );

void p(float x=888) { code; }
Nomeie um novo operador op ↑ = ( real x, y) real : x ** y; N / D
Definir a prioridade de uma nova operadora prio ↑ = 9; N / D
Atribuição de variáveis ​​de cadeia a:=b:=c:=d; a = b = c = d;
Operador de deslocamento - ALGOL 68C apenas a:=:=b:=:=c:=:=d; a = b; b = c; c = d;
Anexar "substr" a uma variável str str +:= "substr"; str += "substr";
Prefixo "substr" para uma variável str "substr" +=: str; str = "substr" + str;

Exemplos de código

Declaração de união e uso

A atribuição de valores a uma unionvariável A68 é automática, o tipo é "marcado" para a variável, mas extrair o valor de volta é sintaticamente estranho, pois uma cláusula de conformidade é necessária.

Exemplo ALGOL 68: 

 union(int, char) x:=666;
 printf(($3d l$, (x|(int i):i) ))

Exemplo C / C ++: 

  union { int i; char c; } x = { 666 };
  std::cout << x.i << std::endl;

O efeito líquido da "marcação de tipo" é que a "metade" de tipagem forte do Algol68 invade o union.

Declaração de modo

Um novo modo (tipo) pode ser declarado usando uma modedeclaração: 

int max=99;
mode newtype = [0:9][0:max]struct (
   long real a, b, c, short int i, j, k, ref real r
);

Isso tem o efeito semelhante ao seguinte código C ++: 

const int max=99;
typedef struct { 
    double a, b, c; short i, j, k; float& r;
} newtype[9+1][max+1];

Observe que para ALGOL 68 apenas o nome do novo tipo aparece à esquerda da igualdade e, mais notavelmente, a construção é feita - e pode ser lida - da esquerda para a direita, independentemente das prioridades.

links externos