Curso de C#: Liçao 2: Operadores, Tipos e Variáveis

Esta lição introduz aos operadores, tipos e variáveis do C#. Seu objetivo é atender as seguintes necessidades: Entenda o que é uma variável. Familiarização com C # built-in types. Obter uma introdução aos operadores. Saiba como usar Arrays.

Por | @oficinadanet Programação
<p>Esta li&ccedil;&atilde;o introduz aos operadores, tipos e vari&aacute;veis do C#. Seu objetivo &eacute; atender as seguintes necessidades:</p> <ul> <li>Entenda o que &eacute; uma vari&aacute;vel.</li> <li>Familiariza&ccedil;&atilde;o com C # built-in types.</li> <li>Obter uma introdu&ccedil;&atilde;o aos operadores.</li> <li>Saiba como usar Arrays.</li> </ul> <p>&nbsp;</p> <h3>Vari&aacute;veis e tipos</h3> <p>"Vari&aacute;veis" s&atilde;o simplesmente locais de armazenamento de dados. Voc&ecirc; pode colocar os dados e recuper&aacute;-los em seu conte&uacute;do como parte de uma express&atilde;o. A interpreta&ccedil;&atilde;o dos dados em uma vari&aacute;vel &eacute; controlada atrav&eacute;s de "Tipos" ou no ingl&ecirc;s "types".&nbsp;Todas as opera&ccedil;&otilde;es sobre vari&aacute;veis s&atilde;o realizadas com considera&ccedil;&atilde;o de que a vari&aacute;vel do "Type". Existem regras que definem quais as opera&ccedil;&otilde;es s&atilde;o legais, a fim de manter a integridade dos dados que voc&ecirc; colocou em uma vari&aacute;vel.</p> <p>H&aacute; tipos simples que consistem do tipo booleana e tr&ecirc;s tipos num&eacute;ricos - <em>Integer, Float, Decimal, e String</em>. O termo "Integer", que &eacute; definido no <em>C # Programming Language Specification</em>, refere-se &agrave; classifica&ccedil;&atilde;o dos tipos que incluem <em>sbyte, byte, short, ushort, int, uint, long, ulong, e char</em>. Mais informa&ccedil;&otilde;es est&atilde;o dispon&iacute;veis na se&ccedil;&atilde;o Integral Tipos posteriormente nesta li&ccedil;&atilde;o. O termo "<em>Float</em>" refere-se &agrave;<em> float e double </em>types, que s&atilde;o discutidos, juntamente com o tipo <em>decimal</em>, com mais detalhes no Ponto Flutuante e Decimal Tipos sec&ccedil;&atilde;o posteriormente nesta li&ccedil;&atilde;o. A <em>string </em>tipo representa um conjunto de caracteres e &eacute; discutido na sec&ccedil;&atilde;o <em>String Types</em>, posteriormente nesta li&ccedil;&atilde;o. A pr&oacute;xima se&ccedil;&atilde;o introduz o tipo booleano.</p> <h3 class="interno">Tipo Boolean</h3> <p>Booleano ou boolean s&atilde;o declarados usando a palavra-chave, <strong>bool</strong>. Eles t&ecirc;m dois valores: verdadeiro ou falso. Em outras linguagens, como C, C + +, condi&ccedil;&otilde;es podem ser satisfeitos onde 0 significa falso e qualquer outra coisa, significa verdadeira. No entanto, em C # apenas os valores que satisfazem uma condi&ccedil;&atilde;o boolean &eacute; verdadeiro e falso (true, false), que s&atilde;o as palavras-chave oficiais. Listagem 2-1 mostra uma das muitas maneiras que tipos boolean podem ser usados em um programa.<br /> <br /> <span style="text-decoration: underline;">Listagem 2-1. Mostrando tipo booleano: Boolean.cs</span></p> <pre><code>using System;<br /> <br /> class Booleans<br /> {<br /> public static void Main()<br /> {<br /> bool content = true;<br /> bool noContent = false;<br /> <br /> Console.WriteLine("It is {0} that C# Station provides C# programming language content.", content);<br /> Console.WriteLine("The statement above is not {0}.", noContent);<br /> }<br /> } </code></pre> <p><br /> <br /> Na Listagem 2-1, so valores boolean s&atilde;o escritos para o console como parte de uma frase. Os &uacute;nicos valores v&aacute;lidos para o tipo bool ou s&atilde;o verdadeiras ou falsas, como demonstra a atribui&ccedil;&atilde;o de verdade ao <span style="text-decoration: underline;">content </span>e aos falsos <span style="text-decoration: underline;">noContent</span>. Quando executado, esse programa produz os seguintes resultados:</p> <pre><code>It is True that C# Station provides C# programming language content.<br /> The statement above is not False.</code></pre> <p>&nbsp;</p> <h3 class="interno">Tipo Integer</h3> <p><br /> Em C #, o tipo inteiro ou <em>integer</em> &eacute; de uma categoria de tipos para n&uacute;meros. A palavra <span style="text-decoration: underline;">inteiro</span> soa como uma express&atilde;o matem&aacute;tica, a partir da perspectiva de programa&ccedil;&atilde;o C #, estas s&atilde;o, na realidade, definidas como <em>Integer types</em> na linguagem de programa&ccedil;&atilde;o C#. S&atilde;o n&uacute;meros inteiros, quer assinado ou n&atilde;o assinado. <br /> <br /> Tabela 2-1 mostra o integrante tipos, a sua dimens&atilde;o e alcance.<br /> <img src="https://www.oficinadanet.com.br/imagens/conteudos/160/c_sharp/tabela_2_1.gif" border="0" alt="" /><br /> <br /> Inteiros s&atilde;o bem adequados para as opera&ccedil;&otilde;es que envolvem c&aacute;lculos num&eacute;ricos. O tipo char &eacute; a excep&ccedil;&atilde;o, o que representa um &uacute;nico caracter Unicode. Como voc&ecirc; pode ver a partir do quadro acima, voc&ecirc; tem uma vasta gama de op&ccedil;&otilde;es de escolha, dependendo de suas necessidades.</p> <h3 class="interno">Tipo Float e Decimal</h3> <p><br /> O ponto flutuante &eacute; tanto float ou double. Eles s&atilde;o usados a qualquer momento que voc&ecirc; precisa para representar um n&uacute;mero real, tal como definido pelo IEEE 754. Para mais informa&ccedil;&otilde;es sobre o IEEE 754, visite o <a href="http://www.ieee.org/" target="_blank">Web Site IEEE</a>. O tipo Decimal deve ser usado quando representa um valor financeiro, dinheiro ou valores. <br /> <br /> <span style="text-decoration: underline;">Tabela 2-2 mostra o ponto flutuante e decimal, a sua dimens&atilde;o, a precis&atilde;o, e varia&ccedil;&atilde;o.</span><br /> <img src="https://www.oficinadanet.com.br/imagens/conteudos/160/c_sharp/tabela_2_2.gif" border="0" alt="" /><br /> <br /> Tipos de ponto flutuante s&atilde;o usados quando se necessita para realizar as opera&ccedil;&otilde;es que exijam representa&ccedil;&otilde;es fracion&aacute;ria. No entanto, para c&aacute;lculos financeiros, o tipo decimal &eacute; a melhor op&ccedil;&atilde;o, porque voc&ecirc; pode evitar erros de arredondamentos.</p> <h3 class="interno">Tipo String</h3> <p><br /> Uma string &eacute; uma seq&uuml;&ecirc;ncia de caracteres texto. Voc&ecirc; normalmente cria uma string com uma string literal, delimitada entre aspas: "Este &eacute; um exemplo de uma string." Voc&ecirc; viu strings sendo usado desde Aula 1, em que utilizou o m&eacute;todo Console.WriteLine para enviar sa&iacute;da para o console.<br /> <br /> Alguns caracteres n&atilde;o s&atilde;o impressos, mas ainda precisa us&aacute;-los em strings. Portanto, C # tem uma sintaxe especial onde personagens podem ser <em>escaped </em>para representar caracteres n&atilde;o imprim&iacute;veis. Por exemplo, &eacute; comum a utiliza&ccedil;&atilde;o newlines (quebra de linha) no texto, que &eacute; representada pela 'n'. A barra invertida, '', representa a fuga. Quando antecedida pela fuga personagem, o 'n' j&aacute; n&atilde;o &eacute; interpretada como um car&aacute;cter alfab&eacute;tico, mas j&aacute; representa uma nova linha.<br /> <br /> Voc&ecirc; pode estar pensando como voc&ecirc; agora pode representar uma barra de caracteres em seu c&oacute;digo. Temos de escape que tamb&eacute;m escrevendo dois barra, como em ' '. <br /> <br /> <span style="text-decoration: underline;">Tabela 2-3 mostra uma lista de seq&uuml;&ecirc;ncias comuns escapar.</span><br /> <img src="https://www.oficinadanet.com.br/imagens/conteudos/160/c_sharp/tabela_2_3.gif" border="0" alt="" /></p> <h3 class="interno">Operadores</h3> <p><br /> Os resultados s&atilde;o calculados pela constru&ccedil;&atilde;o express&otilde;es. Estas express&otilde;es s&atilde;o constru&iacute;das pela combina&ccedil;&atilde;o de vari&aacute;veis e operadores juntos em declara&ccedil;&otilde;es. A tabela a seguir descreve os operadores admiss&iacute;veis, a sua preced&ecirc;ncia, e associativity.<br /> <br /> <span style="text-decoration: underline;">Tabela 2-4. Operadores com sua preced&ecirc;ncia e Associativity</span><br /> <img src="https://www.oficinadanet.com.br/imagens/conteudos/160/c_sharp/gd_tabela_2_4.gif" border="0" alt="" /><br /> <br /> <em>Associativity left</em> significa que as opera&ccedil;&otilde;es s&atilde;o avaliadas da esquerda para a direita. <em>Associativity right</em> significar todas as opera&ccedil;&otilde;es ocorrem da direita para a esquerda, como a cess&atilde;o operadores &agrave; direita onde tudo &eacute; avaliado antes o resultado seja colocado em uma vari&aacute;vel &agrave; esquerda.<br /> <br /> A maioria dos operadores s&atilde;o ou un&aacute;rio ou bin&aacute;rio. Un&aacute;rio operadores forma express&otilde;es em uma &uacute;nica vari&aacute;vel, mas operadores forma bin&aacute;ria express&otilde;es com duas vari&aacute;veis. <br /> <br /> <span style="text-decoration: underline;">Listagem 2-2 demonstra como un&aacute;rio operadores s&atilde;o usados.</span></p> <pre><code><br />     using System;<br /> <br />     class Unary<br />     {<br />         public static void Main()<br />         {<br />             int unary = 0;<br />             int preIncrement;<br />             int preDecrement;<br />             int postIncrement;<br />             int postdecrement;<br />             int positive;<br />             int negative;<br />             sbyte bitNot;<br />             bool logNot;<br /> <br />             preIncrement = ++unary;<br />             Console.WriteLine("pre-Increment: {0}", preIncrement);<br /> <br />             preDecrement = --unary;<br />             Console.WriteLine("pre-Decrement: {0}", preDecrement);<br /> <br />             postdecrement = unary--;<br />             Console.WriteLine("Post-Decrement: {0}", postdecrement);<br /> <br />             postIncrement = unary++;<br />             Console.WriteLine("Post-Increment: {0}", postIncrement);<br /> <br />             Console.WriteLine("Final Value of Unary: {0}", unary);<br /> <br />             positive = -postIncrement;<br />             Console.WriteLine("Positive: {0}", positive);<br /> <br />             negative = +postIncrement;<br />             Console.WriteLine("Negative: {0}", negative);<br /> <br />             bitNot = 0;<br />             bitNot = (sbyte)(~bitNot);<br />             Console.WriteLine("Bitwise Not: {0}", bitNot);<br /> <br />             logNot = false;<br />             logNot = !logNot;<br />             Console.WriteLine("Logical Not: {0}", logNot);<br />         }<br />     } </code></pre> <p><br /> <br /> o avaliar express&otilde;es, p&oacute;s-incremento (x + +) e p&oacute;s-decrementar (x -) operadores retornar seu valor atual e, em seguida, aplicar as operadoras. No entanto, quando se utiliza pr&eacute;-incremento (+ + x) e pr&eacute;-decrementar (- x) operadores, o operador &eacute; aplicado a uma vari&aacute;vel antes de retornar o valor final.<br /> <br /> Em Listing 2-2, o un&aacute;rio vari&aacute;vel &eacute; inicializado a zero. Quando o pr&eacute;-incremento (+ + x) operador &eacute; utilizado, un&aacute;rio a 1 e &eacute; incrementado o valor 1 &eacute; atribu&iacute;do ao preIncrement vari&aacute;vel. O pr&eacute;-decrementar (- x) operador un&aacute;rio vira costas a um 0 e, em seguida, atribui o valor &agrave; vari&aacute;vel preDecrement.<br /> <br /> Quando o p&oacute;s-decrementar (x -) operador &eacute; utilizado, o valor de un&aacute;rio, 0, &eacute; colocado na postdecrement vari&aacute;vel e, em seguida, un&aacute;rio &eacute; diminu&iacute;do para -1. Em seguida o p&oacute;s-incremento (x + +) operador move o valor atual da un&aacute;rio, -1, a postIncrement vari&aacute;vel e, em seguida, incrementos un&aacute;rio a 0.<br /> <br /> A vari&aacute;vel bitNot &eacute; inicializado a zero e n&atilde;o o bitwise (~) operador &eacute; aplicada. A n&atilde;o bitwise (~) vira o operador bits na vari&aacute;vel. Neste caso, a representa&ccedil;&atilde;o bin&aacute;ria de 0, "00000000", foi transformada em -1, "11111111".<br /> <br /> Aviso a express&atilde;o (sbyte) (~ bitNot). Qualquer opera&ccedil;&atilde;o realizada em tipos sbyte, byte, short, int ou ushort retornar valores. Para atribuir o resultado para a vari&aacute;vel bitNot tivemos que utilizar um cast (Type) operador, em que tipo &eacute; o tipo que voc&ecirc; deseja converter (neste caso - sbyte). O elenco operador &eacute; apresentado como o Unary operador "(T) x" na tabela 2-4. Cast operadores devem ser realizadas explicity quando voc&ecirc; passar de um maior para um tipo menor tipo, porque o potencial de perda de dados. De uma forma geral, atribui&ccedil;&atilde;o de um tipo menor para um maior tipo &eacute; nenhum problema, uma vez que o maior tipo tem espa&ccedil;o para realizar todo o valor. Tamb&eacute;m estar conscientes dos perigos de casting entre tipos assinados e n&atilde;o assinados. Voc&ecirc; quer ter a certeza de preservar a integridade dos seus dados. Muitos textos b&aacute;sicos de programa&ccedil;&atilde;o cont&eacute;m boas descri&ccedil;&otilde;es de bit representa&ccedil;&otilde;es de vari&aacute;veis e os perigos de casting expl&iacute;cito.<br /> <br /> A l&oacute;gica n&atilde;o (!) Operador lhe permite mudar o valor de uma vari&aacute;vel booleana. No exemplo, o logNot vari&aacute;vel &eacute; alterado de false para true. Voc&ecirc; pode esperar o resultado do referido programa.</p> <blockquote>Pr&eacute;-Incremento: 1<br /> Pr&eacute;-Decrement 0<br /> Post-Decrement: 0<br /> P&oacute;s-Incremento: -1<br /> O valor final do Unary: 0<br /> Positivo: 1<br /> Negativo: -1<br /> N&atilde;o bitwise: -1<br /> N&atilde;o &eacute; l&oacute;gico: true</blockquote> <p><br /> <br /> Al&eacute;m de un&aacute;rio operadores, C # tem bin&aacute;rio operadores que formam express&otilde;es de duas vari&aacute;veis. Listagem 2-3 mostra como usar o bin&aacute;rio operadores.<br /> <br /> <span style="text-decoration: underline;">Listagem 2-3. Operadores Bin&aacute;rios: Binary.cs</span></p> <pre><code>using System;<br /> <br /> class Binary<br /> {<br /> public static void Main()<br /> {<br /> int x, y, result;<br /> float floatresult;<br /> <br /> x = 7;<br /> y = 5;<br /> <br /> result = x+y;<br /> Console.WriteLine("x+y: {0}", result);<br /> <br /> result = x-y;<br /> Console.WriteLine("x-y: {0}", result);<br /> <br /> result = x*y;<br /> Console.WriteLine("x*y: {0}", result);<br /> <br /> result = x/y;<br /> Console.WriteLine("x/y: {0}", result);<br /> <br /> floatresult = (float)x/(float)y;<br /> Console.WriteLine("x/y: {0}", floatresult);<br /> <br /> result = x%y;<br /> Console.WriteLine("x%y: {0}", result);<br /> <br /> result += x;<br /> Console.WriteLine("result+=x: {0}", result);<br /> }<br /> } </code></pre> <p><br /> <br /> A sa&iacute;da &eacute;:</p> <blockquote>x+y: 12 <br /> x-y: 2 <br /> x*y: 35 <br /> x/y: 1 <br /> x/y: 1.4 <br /> x%y: 2 <br /> result+=x: 9</blockquote> <p><br /> <br /> Listagem 2-3 mostra v&aacute;rios exemplos de operadores bin&aacute;rios. Como voc&ecirc; poderia esperar, os resultados de adi&ccedil;&atilde;o (+), subtra&ccedil;&atilde;o (-), a multiplica&ccedil;&atilde;o (*), ea divis&atilde;o (/) produzir os resultados esperados matem&aacute;tico.<br /> <br /> O floatresult vari&aacute;vel &eacute; um tipo de ponto flutuante. N&oacute;s explicitamente o elenco inteiro vari&aacute;veis x e y para calcular um valor de ponto flutuante.<br /> <br /> Existe tamb&eacute;m um exemplo do restante (%) operador. Ele executa uma opera&ccedil;&atilde;o divis&atilde;o, em dois valores e retorna o resto.<br /> <br /> A &uacute;ltima declara&ccedil;&atilde;o revela uma outra forma de cess&atilde;o com a opera&ccedil;&atilde;o (+ =) operador. Todas as vezes que voc&ecirc; utilizar a atribui&ccedil;&atilde;o com opera&ccedil;&atilde;o operador, que &eacute; o mesmo que a aplica&ccedil;&atilde;o do operador bin&aacute;rio para tanto a m&atilde;o esquerda ea m&atilde;o direita lados do operador e colocar os resultados para o lado esquerdo. O exemplo poderia ter sido escrita como resultado resultado + = x; e retornado o mesmo valor.</p> <h3 class="interno">Tipo Array</h3> <p><br /> Outro tipo de dados &eacute; o Array, que podem ser consideradas como um contentor que tem uma lista de locais de armazenamento de um tipo especificado. Ao declarar um Array, especificar o tipo, nome, dimens&otilde;es e tamanho.<br /> <br /> Listagem 2-4. Operadores Arrays: Array.cs</p> <pre><code>using System;<br /> <br /> class Array<br /> {<br /> public static void Main()<br /> {<br /> int[] myInts = { 5, 10, 15 };<br /> bool[][] myBools = new bool[2][];<br /> myBools[0] = new bool[2];<br /> myBools[1] = new bool[1];<br /> double[,] myDoubles = new double[2, 2];<br /> string[] myStrings = new string[3];<br /> <br /> Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0], myInts[1], myInts[2]);<br /> <br /> myBools[0][0] = true;<br /> myBools[0][1] = false;<br /> myBools[1][0] = true;<br /> Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0], myBools[1][0]);<br /> <br /> myDoubles[0, 0] = 3.147;<br /> myDoubles[0, 1] = 7.157;<br /> myDoubles[1, 1] = 2.117;<br /> myDoubles[1, 0] = 56.00138917;<br /> Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}", myDoubles[0, 0], myDoubles[1, 0]);<br /> <br /> myStrings[0] = "Joe";<br /> myStrings[1] = "Matt";<br /> myStrings[2] = "Robert";<br /> Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}", myStrings[0], myStrings[1], myStrings[2]);<br /> <br /> }<br /> } </code></pre> <p><br /> <br /> A sa&iacute;da:</p> <blockquote>myInts[0]: 5, myInts[1]: 10, myInts[2]: 15<br /> myBools[0][0]: true, myBools[1][0]: true<br /> myDoubles[0, 0]: 3.147, myDoubles[1, 0]: 56.00138917<br /> myStrings[0]: Joe, myStrings[1]: Matt, myStrings[2]: Robert</blockquote> <p><br /> <br /> Listagem 2-4 mostra diferentes implementa&ccedil;&otilde;es de Arrays. O primeiro exemplo &eacute; o myInts Array, que &eacute; uma dimens&atilde;o &uacute;nica-array. &Eacute; inicializada no tempo com a declara&ccedil;&atilde;o expl&iacute;cita valores.<br /> <br /> Seguinte &eacute; um array retalhadas, myBools. &Eacute; essencialmente um array de arrays. Precis&aacute;vamos de usar o novo operador que exemplificam o tamanho do array prim&aacute;rio e, em seguida, usar o novo operador novamente para cada sub-array.<br /> <br /> O terceiro exemplo &eacute; um array bidimensional, myDoubles. Arrays podem ser multi-dimensional, com cada dimens&atilde;o separados por uma v&iacute;rgula. Por outro lado, deve ser instanciado com o novo operador.<br /> <br /> Uma das diferen&ccedil;as entre arrays retalhadas, myBools [][], e multi-dimens&atilde;o arrays, myDoubles [,], que &eacute; um programa multi-dimens&atilde;o array ir&aacute; alocar mem&oacute;ria para cada elemento de cada dimens&atilde;o, que um array retalhadas s&oacute; ir&aacute; alocar mem&oacute;ria Para o tamanho de cada variedade de cada dimens&atilde;o que voc&ecirc; define. Na maioria das vezes, voc&ecirc; estar&aacute; usando arrays multi-dimens&atilde;o, se voc&ecirc; precisar de m&uacute;ltiplas dimens&otilde;es, e s&oacute; usar retalhadas arrays em circunst&acirc;ncias muito especiais, quando voc&ecirc; &eacute; capaz de guardar significativo mem&oacute;ria por explicitamente especificando os tamanhos dos arrays em cada dimens&atilde;o .<br /> <br /> Finalmente, temos o &uacute;nico-dimensional variedade de tipos string, myStrings.<br /> <br /> Em cada caso, voc&ecirc; pode ver que a matriz elementos s&atilde;o acessados por inteiro para identificar o &iacute;ndice para o item que voc&ecirc; deseja referir-se. Arrays tamanho pode ser qualquer tipo int valor. Os &iacute;ndices come&ccedil;am em 0.</p> <h3 class="interno">Resumo</h3> <p><br /> A vari&aacute;vel &eacute; um identificador com um tipo que det&eacute;m um valor desse tipo. Simple tipos incluem as integrais, pontos flutuantes, decimal, e bool. C # tem v&aacute;rios operadores l&oacute;gicos e matem&aacute;ticos que participam na forma&ccedil;&atilde;o de express&otilde;es. C # tamb&eacute;m oferece a &uacute;nica dimens&atilde;o, multi-dimens&atilde;o e retalhadas array tipos.<br /> <br /> Nesta li&ccedil;&atilde;o voc&ecirc; aprendeu como escrever simples declara&ccedil;&otilde;es e c&oacute;digo de um programa que funciona linearmente do come&ccedil;o ao fim. No entanto, este n&atilde;o &eacute; t&atilde;o &uacute;til como ele pode ser porque voc&ecirc; precisa ser capaz de tomar decis&otilde;es e executar diferentes blocos de c&oacute;digo dependendo das diferentes condi&ccedil;&otilde;es. Convido voc&ecirc; a troco de Aula 3: Controle Declara&ccedil;&otilde;es - Sele&ccedil;&atilde;o, onde voc&ecirc; pode aprender a sucursal sua l&oacute;gica para a tomada de decis&otilde;es mais poderosas.<br /> <br /> <strong>Tradu&ccedil;&atilde;o do artigo:</strong> <a href="http://www.csharp-station.com/Tutorials/Lesson02.aspx" target="_blank">http://www.csharp-station.com/Tutorials/Lesson02.aspx</a></p>

Mais sobre: curso_c# especial_c#
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo

Siga nossas contas no Twitter