Tabela que mostra uma comparação entre os comandos do Portugol (Visualg) e do C# de forma a ajudar o aluno na transição entre uma linguagem e outra.
Essa tabela pode ser encontrada para
download no e-book O Senhor dos Algoritmos.
Comando | Portugol | C# |
---|---|---|
Variável tipo inteiro | i: inteiro | sbyte i; short i; int i; long i; byte i; ushort i; uint i; ulong i; |
Variável tipo real | d: real | float d; double d; decimal d: |
Variável tipo lógico | b: logico | bool b; |
Variável tipo texto | s: caractere | char s; string s; |
Variável tipo vetor | v: vetor[linha1..linhaN] de tipo | tipo[] v = new tipo[linhas]; |
Variável tipo matriz | m: vetor[linha1..linhaN, coluna1..colunaN] de tipo | tipo[,] m = new tipo[linhas, colunas]; |
Exemplos de literais (valores) do tipo inteiro | 3 | 3 // int 3L // long 3U // unsigned int 3UL // unsigned long |
Exemplos de literais (valores) do tipo real | 3.14 | 3.14F // float 3.14 // double 3.14M // decimal |
Exemplos de literais (valores) do tipo lógico | FALSO VERDADEIRO | false true |
Exemplos de literais (valores) do tipo texto | "texto entre aspas" | 'C' // char "texto entre aspas" // string |
Ler valor tipo inteiro | leia(i) | i = sbyte.Parse(Console.ReadLine()); i = short.Parse(Console.ReadLine()); i = int.Parse(Console.ReadLine()); i = long.Parse(Console.ReadLine()); i = byte.Parse(Console.ReadLine()); i = ushort.Parse(Console.ReadLine()); i = uint.Parse(Console.ReadLine()); i = ulong.Parse(Console.ReadLine()); |
Ler valor tipo real | leia(d) | d = float.Parse(Console.ReadLine()); d = double.Parse(Console.ReadLine()); d = decimal.Parse(Console.ReadLine()); |
Ler valor tipo lógico | leia(b) | b = bool.Parse(Console.ReadLine()); |
Ler valor tipo texto | leia(s) | s = char.Parse(Console.ReadLine()); s = Console.ReadLine(); |
Escrever | escreva(...) | Console.Write(...); |
Escrever, pulando linha | escreval(...) | Console.WriteLine(...); |
Escrever com parâmetros | escreva(..., a, ..., b, ...) | Console.Write("...{0}...{1}...", a, b, …); Para saber mais opções de formatação, consulte a documentação do C#. |
Escrever com parâmetros, pulando linha | escreval(..., a, ..., b, ...) | Console.WriteLine("...{0}...{1}...", a, b, …); Para saber mais opções de formatação, consulte a documentação do C#. |
Limpar tela | limpatela | Console.Clear(); |
Operação de atribuição (recebe) | a <- b | a = b; |
Operação de adição | a + b | a + b |
Operação de subtração | a - b | a - b |
Operação de multiplicação | a * b | a * b |
Operação de divisão | a / b | a / b |
Operação de divisão inteira | a \ b | a / b (sendo a e b inteiros) |
Operação de resto da divisão | a % b a mod b | a % b |
Operação de potenciação | a ^ b | Math.Pow(a, b) |
Operação de raiz quadrada | RaizQ(a) | Math.Sqrt(a) |
Operação de concatenação | "texto" + "texto" "texto" + a a + "texto" | "texto" + "texto" "texto" + a a + "texto" |
Operação de acesso a um valor do vetor | v[índice da linha] | v[índice da linha] (índice começa em 0 e termina em tamanho - 1) |
Operação de acesso a um valor da matriz | m[índice da linha, índice da coluna] | m[índice da linha, índice da coluna] (índices começam em 0 e terminam em tamanho - 1) |
Operação de acesso ao tamanho do vetor | (não tem operador específico) | v.Length |
Operação de acesso ao tamanho da matriz | (não tem operador específico) | m.Length |
Operação de acesso à quantidade de dimensões da matriz | (não tem operador específico) | m.Rank |
Operação de acesso ao tamanho das dimensões da matriz | (não tem operador específico) | m.GetLength(índice da dimensão) (índices começam em 0 e terminam em tamanho - 1) |
Operação menor | a < b | a < b |
Operação menor ou igual | a <= b | a <= b |
Operação maior | a > b | a > b |
Operação maior ou igual | a >= b | a >= b |
Operação igual | a = b | a == b |
Operação diferente | a <> b | a != b |
Operação e | a e b | a && b |
Operação ou | a ou b | a || b |
Operação ou-exclusivo | a xou b | (não tem operador específico) |
Operação de negação | nao a | !a |
Operação bit-a-bit e | (não tem operador específico) | a & b |
Operação bit-a-bit ou | (não tem operador específico) | a | b |
Operação bit-a-bit ou-exclusivo | (não tem operador específico) | a ^ b |
Operação bit-a-bit de negação | (não tem operador específico) | ~a |
Operação de incremento | (não tem operador específico, mas pode ser feito com a <- a + 1) | a++ ++a |
Operação de decremento | (não tem operador específico, mas pode ser feito com a <- a - 1) | a-- --a |
Operação com atribuição | (não tem operador específico) | a op= b (é o mesmo que a = a op b) |
Comando se-então | se condição entao ... fimse | if (condição) { ... } |
Comando se-então-senão | se condição entao ... senao ... fimse | if (condição) { ... } else { ... } |
Comando se-então-senão encadeados | se condição1 entao ... senao se condição2 entao ... senao ... fimse fimse | if (condição1) { ... } else { if (condição2) { ... } else { ... } } |
Comando se-então-senão encadeados (versão melhorada do C#) | se condição1 entao ... senao se condição2 entao ... senao ... fimse fimse | if (condição1) { ... } else if (condição2) { ... } else { ... } |
Comando escolha-caso | escolha variável caso valor1 ... caso valor2, valor3 ... outrocaso ... fimescolha | switch (variável) { case valor1: ... break; case valor2: case valor3: ... break; default: ... break; } |
Comando enquanto-faça | enquanto condição faca ... fimenquanto | while (condição) { ... } |
Comando para | para variável de valor1 ate valorN passo P faca ... fimpara | for (variável = valor1; variável <= valorN; variável += P) { ... } |
Comando repita-até (termina com condição verdadeira) | repita ... ate condição | (não tem comando específico) |
Comando faça-enquanto (termina com condição falsa) | (não tem comando específico) | do { ... } while (condição); |
Comando de interrupção | interrompa | break; |
Comando de próxima iteração | (não tem comando específico) | continue; |
Criar procedimento | procedimento nome(parâmetro: tipo; ...) var ... inicio ... fimprocedimento | static void nome(tipo parâmetro, ...) { ... } |
Criar função | funcao nome(parâmetro: tipo; ...): tipo var ... inicio ... retorne valor fimfuncao | static tipo nome(tipo parâmetro, ...) { ... return valor; } |
Chamar procedimento | nome(valor, ...) | nome(valor, ...); |
Chamar função | a <- nome(valor, ...) | a = nome(valor, ...); |
Mano, mt obg, eu tava lascado pra fzr uns bglh em C e agr vc me ajudou pra caralho
Que show, Carlos!
Maravilha esse post, me ajudou muito!
Que bom, Vinicius!
Fico feliz!
Sucesso!
Olá, muito obrigada! Estava com grande dificuldade em achar a comparação dessas duas linguagens…
Oi, Karine!
Que bom que ajudou! 😉
Bons estudos e sucesso!