MICROSOFT VISUAL C++ .NET PASSO A PASSO (Julian Templeman & Andy Olsen) INTRODUO ........................................................................................... XI PARTE 1: INICIALIZAO EM C++ .NET................................................... 14

1.

HELLO, C++!.................................................................................................141.1. O QUE UM PROGRAMA C++?...............................................................................14 1.1.1. C++ UMA LINGUAGEM FORTEMENTE VINCULADA A TIPOS........14 1.1.2. C++ UMA LINGUAGEM EFICIENTE.........................................................14 1.1.3. C++ UMA LINGUAGEM ORIENTADA PARA OBJETOS.......................14 1.1.4. C++ BASEADA EM C (COMO VOC J SUSPEITAVA) ........................15 1.1.5. C++ UMA LINGUAGEM SENSVEL A CARACTERES MAISCULOS E MINSCULOS .................................................................................................................15 1.2. SEU PRIMEIRO PROGRAMA C++ ...........................................................................15 1.2.1. A FUNO main .................................................................................................16 1.2.2. PALAVRAS-CHAVES E IDENTIFICADORES..............................................17 1.3. CRIANDO UM PROGRAMA EXECUTVEL TEORIA ........................................18 1.3.1. EDITANDO OS ARQUIVOS-FONTES DO PROGRAMA ............................18 1.3.2. COMPILANDO OS ARQUIVOS-FONTES .....................................................18 1.3.3. VINCULANDO OS ARQUIVOS-OBJETOS....................................................18 1.3.4. EXECUTANDO E TESTANDO O PROGRAMA............................................18 1.4. CRIANDO UM PROGRAMA EXECUTVEL PRTICA ......................................19 1.4.1. CRIANDO UM PROJETO .................................................................................19 1.4.2. ADICIONANDO UM ARQUIVO-FONTE C++ AO PROJETO....................21 1.4.3. ADICIONANDO CDIGO C++ AO ARQUIVO-FONTE..............................22 1.4.4. CONSTRUINDO O EXECUTVEL .................................................................23 1.4.5. EXECUTANDO O PROGRAMA ......................................................................24 1.5. CONCLUSES .............................................................................................................24 1.6. RPIDAS REFERNCIAS SOBRE O CAPTULO 1................................................24

2. CAPTULO 2: INTRODUO PROGRAMAO ORIENTADA PARA OBJETOS ............................................................................................................252.1. O QUE PROGRAMAO ORIENTADA PARA OBJETOS?................................25 2.2. CARACTERSTICAS DAS LINGUAGENS DE PROGRAMAO ORIENTADA PARA OBJETOS.......................................................................................................................26 2.2.1. ENCAPSULAMENTO ........................................................................................26 2.2.2. HERANA............................................................................................................26 2.2.3. POLIMORFISMO ...............................................................................................27 2.3. CLASSES E OBJETOS ................................................................................................27 2.4. BENFCIOS NO ATO DO DESENVOLVIMENTO...................................................28 2.5. UM EXEMPLO SIMPLES ...........................................................................................29 2.6. RPIDAS REFERNCIAS SOBRE O CAPTULO 2................................................34

3.

CAPTULO 3: VARIVEIS E OPERADORES ..............................................353.1. O QUE UMA VARIVEL?.......................................................................................35 3.2. OS TIPOS FUNDAMENTAIS DE DADOS ................................................................35 3.3. DECLARANDO UMA VARIVEL .............................................................................36 3.3.1. NOMEANDO VARIVEIS ................................................................................37 3.4. DECLARANDO MLTIPLAS VARIVEIS...............................................................37 3.5. NOMEANDO VALORES PARA AS VARIVEIS......................................................37 i

3.6. MATRIZES....................................................................................................................38 3.7. PONTEIROS .................................................................................................................39 3.8. REFERNCIAS............................................................................................................39 3.9. CONSTANTES..............................................................................................................40 3.9.1. CONSTANTE LITERAL ....................................................................................40 3.9.2. CONSTANTE SIMBLICA...............................................................................40 3.10. ENUMERAES .....................................................................................................40 3.11. TIPOS DEFINIDOS PELO USURIO...................................................................41 3.12. ADICIONANDO VARIVEIS-MEMBROS S CLASSES....................................41 3.13. A CLASSE String DO .NET FRAMEWORK ..........................................................44 3.14. OPERADORES E EXPRESSES ...........................................................................45 3.14.1. OPERADORES DE ATRIBUIO...................................................................45 3.14.2. OPERADORES ARITMTICOS ......................................................................453.14.2.1. 3.14.2.2. 3.14.2.3. OPERADORES MATEMTICOS PADRES...........................................................45 OPERADORES ARITMTICOS DE ATRIBUIO ................................................46 OPERADORES DE INCREMENTO E DECREMENTO ...........................................46 OPERADORES RELACIONAIS ................................................................................47 OPERADORES LGICOS..........................................................................................47

3.14.3.

OPERADORES RELACIONAIS E LGICOS................................................47

3.14.3.1. 3.14.3.2.

3.14.4. OPERADORES BIT-A-BIT................................................................................48 3.14.5. O OPERADOR TERNRIO ..............................................................................49 3.14.6. O OPERADOR sizeof ..........................................................................................49 3.14.7. CONVERSO DE TIPOS...................................................................................49 3.14.8. PRECEDNCIA E ASSOCIATIVIDADE DE OPERADORES.....................50 3.15. RPIDAS REFERNCIAS SOBRE O CAPTULO 3............................................51

4.

CAPTULO 4: USANDO FUNES .............................................................524.1. DECLARANDO PROTTIPOS DE FUNO ..........................................................52 4.1.1. DECLARANDO UM PROTTIPO SIMPLES DE FUNO .......................524.1.1.1. EXERCCIO: DECLARANDO UM PROTTIPO DE FUNO ..............................53

4.1.2.4.1.2.1.

DECLARANDO PARMETROS EM UM PROTTIPO DE FUNO .....53EXERCCIO: PROTTIPO DE FUNO COM PARMETROS ............................53

4.1.3. DECLARANDO O TIPO DE RETORNO EM UM PROTTIPO DE FUNO...............................................................................................................................544.1.3.1. EXERCCIO: FUNO COM RETORNO NO-NULO ...........................................54

4.1.4. DECLARANDO VALORES PADRES PARA PARMETROS DE FUNO...............................................................................................................................544.1.4.1. EXERCCIO: PARMETROS PADRES..................................................................54

4.2. DEFININDO OS CORPOS DE FUNO..................................................................55 4.2.1. DEFININDO UM CORPO DE FUNO SIMPLES.......................................554.2.1.1. EXERCCIO: ADICIONANDO O CORPO DE UMA FUNO ...............................56

4.2.2.4.2.2.1.

DEFININDO UM CORPO DE FUNO QUE UTILIZA PARMETROS 56EXERCCIO: CORPO DE FUNO COM PARMETROS.....................................56

4.2.3.4.2.3.1.

DEFININDO UM CORPO DE FUNO QUE RETORNA UM VALOR ...57EXERCCIO: CORPO DE FUNO QUE RETORNA UM VALOR........................57

4.3. CHAMANDO FUNES.............................................................................................59 4.3.1. CHAMANDO FUNES NO APLICATIVO-AMOSTRA ............................59 4.3.2. PERCORRENDO O APLICATIVO COM O DEPURADOR ........................61 4.3.3. COMPREENDENDO O ESCOPO LOCAL E GLOBAL................................644.3.3.1. EXERCCIO: ESCOPO PARA VARIVEL GLOBAL ..............................................65

4.3.4.4.3.4.1.

SOBRECARREGANDO FUNES .................................................................66EXERCCIO: FUNES SOBRECARREGADAS.....................................................66

4.4. ii

RPIDAS REFERNCIAS SOBRE O CAPTULO 4................................................67

5.

CAPTULO 5: DECLARAES DE CONDICIONAIS E DE LAOS............ 695.1. TOMANDO DECISES COM A DECLARAO if ...............................................69 5.1.1. REALIZANDO TESTES SIMPLES ..................................................................695.1.1.1. EXERCCIO: UM NOVO APLICATIVO PARA TESTES SIMPLES........................70

5.1.2.5.1.2.1.

REALIZANDO TESTES DUPLOS ...................................................................73EXERCCIO: TESTE DUPLO ....................................................................................73

5.1.3.5.1.3.1.

REALIZANDO MLTIPLOS TESTES............................................................74EXERCCIO: NMERO MXIMO DE DIAS DE UM DADO MS ........................75

5.1.4.5.1.4.1.

REALIZANDO TESTES ANINHADOS ...........................................................76EXERCCIO: TESTES ANINHADOS.........................................................................77

5.2. TOMANDO DECISES COM A DECLARAO switch......................................78 5.2.1. DEFININDO DECLARAES switch SIMPLES .......................................785.2.1.1. EXERCCIO: MELHORANDO O CalendarAssistant......................................79

5.2.2.5.2.2.1.

DEFININDO PASSAGEM DIRETA EM UMA DECLARAO switch ..80EXERCCIO: PASSAGEM DIRETA EM UMA DECLARAO switch ..............81

5.3. EXECUTANDO LAOS...............................................................................................81 5.3.1. USANDO OS LAOS while.............................................................................825.3.1.1. EXERCCIO: USANDO O LAO while NO PROJETO CalendarAssistant 83

5.3.2.5.3.2.1.

USANDO LAOS for ........................................................................................84EXERCCIO: USADO O LAO for NO PROJETO CalendarAssistant........85

5.3.3.

USANDO LAOS do-while ............................................................................86

5.3.3.1. EXERCCIO: USANDO O LAO do-while NO PROJETO CalendarAssistant................................................................................................................87

5.3.4.5.3.4.1.

REALIZANDO SALTOS INCONDICIONAIS ................................................88EXERCCIO: USANDO SALTOS INCONDICIONAIS NO CalendarAssistant 88

5.4.

RPIDAS REFERNCIAS SOBRE O CAPTULO 5................................................89

PARTE 2: MAIS SOBRE PROGRAMAO ORIENTADA PARA OBJETOS... 92

6.

CAPTULO 6: MAIS SOBRE CLASSES E OBJETOS..................................926.1. ORGANIZANDO CLASSES EM ARQUIVOS DE CABEALHO E ARQUIVOSFONTES ....................................................................................................................................92 6.1.1. DEFININDO UMA CLASSE EM UM ARQUIVO DE CABEALHO .........946.1.1.1. EXERCCIO: CRIANDO O APLICATIVO CreditOrganizer E A CLASSE CreditCardAccount NO ARQUIVO DE CABEALHO CreditCardAccount.h........94

6.1.2.

IMPLEMENTANDO UMA CLASSE EM UM ARQUIVO-FONTE .............95

6.1.2.1. EXERCCIO: IMPLEMENTANDO A CLASSE CreditCardAccount NO ARQUIVO-FONTE CreditCardAccount.cpp.....................................................................95

6.2. CRIANDO E DESTRUINDO OBJETOS ....................................................................97 6.2.1. EXERCCIO: CRIANDO E DELETANDO UM OBJETO CreditCardAccount .......................................................................................................98 6.3. DEFININDO CONSTRUTORES E DESTRUTORES ...............................................99 6.3.1. DEFININDO CONSTRUTORES.......................................................................996.3.1.1. EXERCCIO: UM CONSTRUTOR PARA A CLASSE CreditCardAccount.....99

6.3.2.6.3.2.1.

DEFININDO DESTRUTORES ........................................................................101EXERCCIO: UM DESTRUTOR PARA A CLASSE CreditCardAccount......101

6.4. DEFININDO MEMBROS static DE UMA CLASSE..........................................102 6.4.1. DEFININDO MEMBROS DE DADOS static ............................................1036.4.1.1. EXERCCIO: ADICIONANDO UM MEMBRO DE DADOS static CLASSE CreditCardAccount..............................................................................................................104

6.4.2.

DEFININDO FUNES-MEMBROS static .............................................105 iii

6.4.2.1.

EXERCCIO: FUNO-MEMBRO static NA CLASSE CreditCardAccount 106

6.5. DEFININDO RELAES ENTRE OBJETOS ........................................................107 6.5.1. DEFININDO A CLASSE LoyaltyScheme ..................................................1086.5.1.1. EXERCCIO: DEFININDO A CLASSE LoyaltyScheme EM UM NOVO ARQUIVO DE CABEALHO ....................................................................................................108

6.5.2.

IMPLEMENTANDO A CLASSE LoyaltyScheme ....................................109

6.5.2.1. EXERCCIO: IMPLEMENTANDO A CLASSE LoyaltyScheme EM UM NOVO ARQUIVO DE CABEALHO ....................................................................................................109

6.5.3.

CRIANDO, USANDO E DESTRUINDO OBJETOS LoyaltyScheme.....110

6.5.3.1. EXERCCIO: ESTENDENDO A CLASSE CreditCardAccount PARA SUPORTAR A FUNCIONALIDADE DO ESQUEMA DE LEALDADE..................................110

6.5.4. 6.6.

TESTANDO O APLICATIVO .........................................................................112

6.5.4.1. EXERCCIO: TESTANDO A FUNCIONALIDADE DO ESQUEMA DE LEALDADE .................................................................................................................................112

RPIDAS REFERNCIAS SOBRE O CAPTULO 6..............................................113

7.

CAPTULO 7: CONTROLANDO OS TEMPOS DE VIDA DOS OBJETOS . 1167.1. O GERENCIAMENTO DE MEMRIA TRADICIONAL C++ ...............................116 7.1.1. CRIANDO OBJETOS .......................................................................................116 7.1.2. DELETANDO OBJETOS .................................................................................116 7.1.3. VANTAGENS E DESVANTAGENS DA ALOCAO MANUAL DE MEMRIA .........................................................................................................................117 7.2. A ABORDAGEM .NET...............................................................................................118 7.2.1. FINALIZADORES.............................................................................................119 7.2.2. IMPLEMENTANDO UM FINALIZADOR....................................................1207.2.2.1. EXERCCIO: IMPLEMENTANDO UM FINALIZADOR PARA UMA CLASSE GERENCIADA.............................................................................................................................120

7.2.3. 7.2.4.7.2.4.1.

ALGUNS PONTOS SOBRE FINALIZAO................................................122 USANDO UM MTODO Dispose ................................................................122EXERCCIO: ADICIONANDO SUPORTE Dispose EM UMA CLASSE............122

7.2.5.7.2.5.1.

INTEGRANDO Finalize E Dispose.........................................................123EXERCCIO: USANDO SINALIZADOR PARA LIBERAR RECURSOS ..............124

7.3.

RPIDAS REFERNCIAS SOBRE O CAPTULO 7..............................................126

8.

CAPTULO 8: HERANA ...........................................................................1278.1. PROJETANDO UMA HIERARQUIA HEREDITRIA ..........................................127 8.2. DEFININDO UMA CLASSE-BASE .........................................................................128 8.2.1. EXERCCIO: CRIANDO UM NOVO APLICATIVO, DEFININDO E IMPLEMENTANDO UMA CLASSE-BASE ..................................................................128 8.3. DEFININDO UMA CLASSE-DERIVADA ...............................................................130 8.3.1. EXERCCIO: DEFININDO E IMPLEMENTANDO UMA CLASSEDERIVADA ........................................................................................................................130 8.4. ACESSANDO MEMBROS DA CLASSE-BASE.......................................................132 8.4.1. EXERCCIO: DEFININDO E IMPLEMENTANDO A CLASSEDERIVADA SavingsAccount......................................................................................133 8.5. CRIANDO OBJETOS.................................................................................................134 8.5.1. EXERCCIO: CRIANDO OBJETOS CurrentAccount E SavingsAccount ............................................................................................................134 8.6. SOBREPONDO FUNES-MEMBROS .................................................................136 8.6.1. EXERCCIO: FUNO VIRTUAL E FUNO VIRTUAL PURA...........137 8.7. DEFININDO CLASSES SELADAS ..........................................................................139 8.8. DEFININDO E USANDO INTERFACES................................................................140

iv

8.9.

RPIDAS REFERNCIAS SOBRE O CAPTULO 8..............................................140

PARTE 3: FUNDAMENTOS DE PROGRAMAO NO MICROSOFT .NET .. 142

9.

CAPTULO 9: TIPOS DE VALOR ...............................................................1429.1. TIPOS DE REFERNCIA E TIPOS DE VALOR....................................................142 9.1.1. A NECESSIDADE DE TIPOS DE VALOR ....................................................142 9.1.2. PROPRIEDADES DOS TIPOS DE VALOR ..................................................143 9.2. ESTRUTURAS ............................................................................................................144 9.2.1. EXERCCIO: CRIANDO E USANDO UMA ESTRUTURA SIMPLES .....144 9.2.2. EXERCCIO: INVESTIGANDO A ESTRUTURA........................................145 9.2.3. DIFERENAS ENTRE ESTRUTURAS E CLASSES...................................147 9.2.4. EXERCCIO: IMPLEMENTANDO CONSTRUTORES PARA UMA ESTRUTURA .....................................................................................................................147 9.2.5. USANDO UMA ESTRUTURA DENTRO DE OUTRA.................................1489.2.5.1. EXERCCIO: INVESTIGANDO COMO FUNCIONAM MEMBROS DE DADOS DE ESTRUTURA ...............................................................................................................................148

9.2.6. COPIANDO ESTRUTURAS ............................................................................151 9.3. ENUMERAES .......................................................................................................151 9.3.1. EXERCCIO: CRIANDO E USANDO UMA ENUMERAO...................151 9.3.2. EXERCCIO: USANDO ENUMERAES EM PROGRAMAS ................152 9.3.3. EVITANDO AMBIGIDADES .......................................................................153 9.3.4. USANDO MEMRIA EFICIENTEMENTE..................................................153 9.4. RPIDAS REFERNCIAS SOBRE O CAPTULO 9..............................................154

10.

CAPTULO 10: SOBRECARREGANDO OPERADORES....................... 155

10.1. O QUE SOBRECARREGAR OPERADOR? .....................................................155 10.1.1. QUAIS OS TIPOS QUE PRECISAM DE OPERADORES SOBRECARREGADOS?..................................................................................................155 10.1.2. O QUE VOC PODE SOBRECARREGAR?.................................................156 10.1.3. REGRAS PARA SOBRECARGA....................................................................156 10.2. SOBRECARREGANDO OPERADORES EM TIPOS GERENCIADOS ............156 10.2.1. SOBRECARREGANDO TIPOS DE VALOR ................................................15710.2.1.1. EXERCCIO: SOBRECARREGANDO OPERADORES ARITMTICOS .............157 EXERCCIO: SOBRECARREGANDO FUNES DE OPERADOR ....................160 EXERCCIO: IMPLEMENTAO DO OPERADOR IGUALDADE.....................163

10.2.2. 10.2.3. 10.2.4. 10.2.5. 10.2.6. 10.2.7.

SOBRECARREGANDO FUNES DE OPERADOR.................................160 IMPLEMENTANDO OPERADORES LGICOS E A IGUALDADE........162 EXERCCIO: IMPLEMENTANDO Equals ................................................165 EXERCCIO: IMPLEMENTANDO ATRIBUIES...................................166 EXERCCIO: IMPLEMENTANDO INCREMENTO E DECREMENTO.168 SOBRECARREGANDO TIPOS DE REFERNCIA ....................................170

10.2.2.1. 10.2.3.1.

10.2.7.1. IMPLEMENTANDO OPERADORES SOBRECARREGADOS PARA TIPOS DE REFERNCIA..............................................................................................................................170

10.2.8. CHAMANDO OPERADORES SOBRECARREGADOS PARA TIPOS DE REFERNCIA ...................................................................................................................170 10.3. DIRETRIZES PARA FORNECIMENTO DE OPERADORES SOBRECARREGADOS..........................................................................................................170 10.4. RPIDAS REFERNCIAS SOBRE O CAPTULO 10........................................171

11.

CAPTULO 11: MANIPULANDO EXCEES ........................................17211.1.1.1. EXERCCIO: ERRO DE DIVISO POR ZERO ......................................................173

11.1. O QUE SO EXCEES?.....................................................................................172 11.1.1. COMO AS EXCEES FUNCIONAM?........................................................173 11.1.2. TIPOS DE EXCEO ......................................................................................174 v

11.2. LANANDO EXCEES......................................................................................174 11.2.1. EXERCCIO: GERANDO UMA EXCEO ................................................176 11.3. MANIPULANDO EXCEES ..............................................................................177 11.3.1. EXERCCIO: FUNDAMENTOS DA MANIPULAO DE EXCEES.178 11.3.2. PERSONALIZANDO A MANIPULAO DE EXCEES.......................179 11.3.3. USANDO A HIERARQUIA DE EXCEO ..................................................180 11.3.4. EXERCCIO: USANDO EXCEES COM CONSTRUTORES................180 11.3.5. ANINHANDO E RELANANDO EXCEES ............................................18111.3.5.1. EXERCCIO: RELANANDO EXCEES............................................................182

11.3.6. EXERCCIO: O BLOCO __finally ...........................................................184 11.3.7. O BLOCO catch(...) ..................................................................................185 11.4. CRIANDO SEUS PRPRIOS TIPOS DE EXCEO.........................................185 11.4.1. EXERCCIO: CRIANDO E USANDO UMA CLASSE DE EXCEO DERIVADA DE Exception ...........................................................................................186 11.4.2. USANDO CLASSES __value ........................................................................187 11.5. USANDO __try_cast PARA CONVERSO DINMICA ...............................188 11.6. USANDO EXCEES NAS LINGUAGENS .NET..............................................189 11.6.1. EXERCCIO: CRIANDO UMA CLASSE C++ E UTILIZANDO-A EM UM APLICATIVO DO VISUAL BASIC ................................................................................189 11.7. RPIDAS REFERNCIAS SOBRE O CAPTULO 11........................................193

12.

CAPTULO 12: MATRIZES E COLEES .............................................194

12.1. MATRIZES NATATIVAS C++ ..............................................................................194 12.1.1. EXERCCIO: CRIANDO E USANDO MATRIZES NATIVAS C++ ..........194 12.1.2. PASSANDO MATRIZES PARA FUNES..................................................19612.1.2.1. EXERCCIO: PASSANDO UMA MATRIZ PARA UMA FUNO......................197

12.1.3. 12.1.4. 12.1.5.

INICIALIZANDO MATRIZES........................................................................197 MATRIZES MULTIDIMENSIONAIS............................................................198EXERCCIO: CRIANDO E USANDO UMA MATRIZ 2D .....................................198 EXERCCIO: CRIANDO E USANDO MATRIZ DINAMICAMENTE ALOCADA 199

12.1.4.1. 12.1.5.1.

ALOCAO DINMICA E MATRIZES ......................................................199

12.1.6. MATRIZES __gc ..............................................................................................200 12.1.7. USANDO AS PALAVRAS-CHAVES __gc E __nogc ................................201 12.1.8. EXERCCIO: MATRIZES E TIPOS DE REFERNCIA ............................201 12.1.9. MATRIZES __gc MULTIDIMENSIONAIS .................................................202 12.2. A CLASSE .NET Array ........................................................................................203 12.2.1. EXERCCIO: OPERAES BSICAS EM MATRIZES ...........................203 12.2.2. OPERAES DE MATRIZ MAIS AVANADAS .......................................20512.2.2.1. 12.2.2.2. 12.2.2.3. EXERCCIO: COPIANDO ELEMENTOS DE MATRIZ.........................................205 EXERCCIO: PROCURANDO ELEMENTOS DE MATRIZ ..................................207 EXERCCIO: ORDENANDO ELEMENTOS DE MATRIZ ....................................207 EXERCCIO: USANDO UM ENUMERADOR NUMA MATRIZ DE STRINGS ..210

12.2.3.

ENUMERADORES ...........................................................................................209

12.2.3.1.

12.3. OUTRAS CLASSES .NET DE COLEO............................................................210 12.3.1. A CLASSE ArrayList....................................................................................21112.3.1.1. 12.3.1.2. EXERCCIO: CRIANDO E MANIPULANDO UM OBJETO ArrayList...........211 OUTRAS OPERAES ArrayList .....................................................................213 EXERCCIO: CRIANDO E MANIPULANDO UM OBJETO SortedList ........214 OUTRAS OPERAES SortedList ...................................................................216

12.3.2.

A CLASSE SortedList .................................................................................214

12.3.2.1. 12.3.2.2.

12.3.3. vi

A CLASSE StringCollection .............................................................................216

12.3.3.1.

EXERCCIO: CRIANDO E MANIPULANDO UM OBJETO StringCollection 216

12.4.

RPIDAS REFERNCIAS SOBRE O CAPTULO 12........................................217

13.

CAPTULO 13: PROPRIEDADES ...........................................................218

13.1. O QUE SO PROPRIEDADES? ...........................................................................218 13.1.1. OS DOIS TIPOS DE PROPRIEDADES..........................................................219 13.2. IMPLEMENTANDO PROPRIEDADES ESCALARES.......................................219 13.2.1. EXERCCIO: IMPLEMENTANDO PROPRIEDADES ESCALARES DE UMA CLASSE....................................................................................................................219 13.2.2. ERROS EM PROPRIEDADES ........................................................................221 13.2.3. PROPRIEDADES SOMENTE PARA LEITURA E SOMENTE PARA ESCRITA ............................................................................................................................22113.2.3.1. EXERCCIO: IMPLEMENTANDO UMA PROPRIEDADE SOMENTE PARA LEITURA E CRIANDO UMA PROPRIEDADE DERIVADA ..................................................221

13.3. IMPLEMENTANDO PROPRIEDADES INDEXADAS.......................................223 13.3.1. O EXEMPLO DO BANCO ...............................................................................223 13.3.2. EXERCCIO: IMPLEMENTANDO A CLASSE Bank ................................223 13.3.3. EXERCCIO: ADICIONANDO UMA CLASSE Account ..........................226 13.3.4. EXERCCIO: CRIANDO PROPRIEDADES PARA A CLASSE Account 228 13.3.5. ADICIONANDO CONTAS NA CLASSE Bank.............................................22813.3.5.1. EXERCCIO: IMPLEMENTANDO OS MTODOS Add E Remove.....................229 13.3.5.2. EXERCCIO: IMPLEMENTANDO UMA PROPRIEDADE INDEXADA PARA RETER CONTAS.........................................................................................................................229

13.4.

RPIDAS REFERNCIAS SOBRE O CAPTULO 13........................................231

14.

CAPTULO 14: DELEGADOS E EVENTOS ............................................232

14.1. O QUE SO DELEGADOS?..................................................................................232 14.1.1. O QUE FAZEM OS DELEGADOS? ...............................................................233 14.1.2. EXERCCIO: DEFININDO DELEGADOS ...................................................233 14.1.3. IMPLEMENTANDO DELEGADOS...............................................................234 14.1.4. EXERCCIO: CHAMANDO FUNES-MEMBROS static USANDO DELEGADOS.....................................................................................................................234 14.1.5. USANDO DELEGADOS PARA CHAMAR FUNES-MEMBROS NO static 235 14.1.6. USANDO DELEGADOS multicast ............................................................23514.1.6.1. EXERCCIO: CRIANDO E USANDO UM DELEGADO multicast .................235

14.2. O QUE SO EVENTOS? .......................................................................................238 14.2.1. EXERCCIO: IMPLEMENTANDO UMA CLASSE DE FONTE DE EVENTOS...........................................................................................................................239 14.2.2. EXERCCIO: IMPLEMENTANDO UM RECEPTOR DE EVENTOS ......240 14.2.3. EXERCCIO: JUNTANDO TUDO..................................................................241 14.3. RPIDAS REFERNCIAS SOBRE O CAPTULO 14........................................244 PARTE 4: USANDO O .NET FRAMEWORK............................................... 246

15.

CAPTULO 15: A BIBLIOTECA DE CLASSES .NET FRAMEWORK ......... 246

15.1. O QUE O .NET Framework?..............................................................................246 15.1.1. A LINGUAGEM COMUM EM TEMPO DE EXECUO .........................246 15.1.2. A LINGUAGEM INTERMEDIRIA..............................................................247 15.1.3. O SISTEMA DE TIPO COMUM .....................................................................247 15.1.4. A ESPECIFICAO DA LINGUAGEM COMUM ......................................247 15.1.5. A BIBLIOTECA DE CLASSES .NET Framework........................................247 vii

15.1.6. 15.1.7.

ASSEMBLIES ....................................................................................................248 METADATA.......................................................................................................249EXERCCIO: MODIFICANDO UM METADATA PADRO ................................249

15.1.7.1.

15.2. OS namespaces DA BIBLIOTECA .NET Framework......................................251 15.2.1. USANDO namespaces EM PROGRAMAS C++.........................................252 15.2.2. O namespace System ...................................................................................25215.2.2.1. 15.2.2.2. TIPOS BSICOS .......................................................................................................253 TIPOS PONTOS-FLUTUANTES..............................................................................254

15.2.3. OS namespaces DE COLEES..................................................................254 15.2.4. AS INTERFACES DAS COLEES..............................................................255 15.2.5. O namespace IO .................................................................................................255 15.2.6. OS namespaces PARA DESENHO...............................................................256 15.2.7. O namespace Forms ...........................................................................................257 15.2.8. OS namespaces Net ............................................................................................258 15.2.9. OS namespaces Xml ...........................................................................................258 15.2.10. OS namespaces Data ......................................................................................258 15.2.11. OS namespaces Web ......................................................................................258 15.3. RPIDAS REFERNCIAS SOBRE O CAPTULO 15........................................259

16.

CAPTULO 16: INTRODUZINDO AS FORMAS DO WINDOWS ............. 260

16.1. APLICATIVOS WINDOWS FORMS ....................................................................260 16.1.1. AS FORMAS DO WINDOWS E AS REAS DE DESENHO ......................261 16.1.2. AS FORMAS DO WINDOWS VERSUS A MFC ...........................................261 16.1.3. UMA PALAVRA SOBRE ATL ........................................................................262 16.2. O namespace System::Windows::Forms................................................................262 16.3. CRIANDO E USANDO FORMAS.........................................................................263 16.3.1. EXERCCIO: CRIANDO UMA FORMA SIMPLES ....................................263 16.3.2. USANDO AS PROPRIEDADES DE Form .....................................................26516.3.2.1. EXERCCIO: USANDO O EDITOR DE PROPRIEDADES....................................268

16.3.3. 16.3.4. 16.3.5.

RELAES ENTRE FORMAS.......................................................................270 EXERCCIO: COLOCANDO CONTROLES NA FORMA .........................271 MANIPULANDO EVENTOS...........................................................................272EXERCCIO: ADICIONANDO MANIPULADORES DE EVENTOS AOS BOTES 273

16.3.5.1.

16.4. USANDO CONTROLES.........................................................................................274 16.4.1. RTULOS ..........................................................................................................27516.4.1.1. EXERCCIO: ADICIONANDO UM RTULO A UMA FORMA E MANIPULANDO SUAS PROPRIEDADES...............................................................................275

16.4.2. 16.4.3. 16.4.4. 16.4.5. 16.4.6.

BOTES .............................................................................................................276 CAIXAS DE CHECAGEM E BOTES DE RDIO .....................................277 USANDO BOTES DE RDIO COM UM GRUPO.....................................278 CAIXAS DE LISTA E CAIXAS COMBO ......................................................278 CAIXAS DE TEXTO .........................................................................................282

16.4.4.1. EXERCCIO: CONFIGURANDO UMA CAIXA DE GRUPO CONTENDO BOTES DE RDIO ...................................................................................................................278 16.4.5.1. EXERCCIO: CONFIGURANDO UMA CAIXA COMBO E RESPONDENDO AOS EVENTOS QUE ELA DISPARA ................................................................................................281 16.4.6.1. EXERCCIO: ADICIONANDO UM CONTROLE DE EDIO PARA MANIPULAO DE TEXTO.....................................................................................................284

16.5. USANDO MENUS ..................................................................................................285 16.5.1. EXERCCIO: ADICIONANDO UM MENU SIMPLES FORMA PRINCIPAL DO APLICATIVO ......................................................................................286 16.5.2. MAIS SOBRE MENUS .....................................................................................288 viii

16.5.3. EXERCCIO: MOSTRANDO UM MENU DE CONTEXTO.......................289 16.6. RPIDAS REFERNCIAS SOBRE O CAPTULO 16........................................290

17.

CAPTULO 17: CAIXAS DE DILOGO E CONTROLES ........................291

17.1. USANDO CAIXAS DE DILOGO ........................................................................291 17.1.1. EXERCCIO: CRIANDO UM CAIXA DE DILOGO About....................292 17.1.2. A PROPRIEDADE DialogResult...............................................................294 17.1.3. EXERCCIO: USANDO DADOS COM CAIXAS DE DILOGO...............295 17.1.4. FIXANDO A ORDEM DE TABULAO......................................................297 17.2. USANDO AS CAIXAS DE DILOGO COMUNS ................................................297 17.2.1. EXERCCIO: ESCOLHENDO UMA FONTE E FIXANDO-A EM UM CONTROLE DE RTULO ..............................................................................................298 17.3. MAIS SOBRE CONTROLES .................................................................................299 17.3.1. USANDO O CONTROLE TreeView.............................................................30017.3.1.1. 17.3.1.2. EXERCCIO: CRIANDO E PREENCHENDO UMA TreeView...........................303 EXERCCIO: ADICIONANDO PASTAS AO NAVEGADOR................................304

17.3.2.

USANDO O CONTROLE ListView.............................................................308

17.3.2.1. EXERCCIO: ADICIONANDO UM CONTROLE DE VISTA DE LISTA FORMA PRINCIPAL..................................................................................................................................310 17.3.2.2. EXERCCIO: MOSTRANDO DETALHES DE UMA PASTA................................312

17.3.3. 17.3.4. 17.3.5.

USANDO DIVISORES ......................................................................................315EXERCCIO: ADICIONANDO UM CONTROLE Splitter A UMA FORMA .315 EXERCCIO: ADICIONANDO UMA ToolBar A UMA FORMA .......................317 EXERCCIO: ADICIONANDO UMA BARRA DE STATUS A UMA FORMA....319 EXERCCIO: MODIFICANDO A BARRA DE STATUS PARA EXIBIR PAINIS 320

17.3.3.1. 17.3.4.1. 17.3.5.1. 17.3.5.2.

USANDO BARRAS DE UTILITRIOS .........................................................315 USANDO BARRAS DE STATUS ....................................................................319

17.4.

RPIDAS REFERNCIAS SOBRE O CAPTULO 17........................................322

18.

CAPTULO 18: SADAS GRFICAS.......................................................323

18.1. GRFICOS COM GDI+ .........................................................................................323 18.1.1. OS namespaces System::Drawing.....................................................................323 18.1.2. A CLASSE Graphics ......................................................................................324 18.1.3. CRIANDO OBJETOS Graphics ...................................................................325 18.1.4. DESENHANDO OBJETOS ..............................................................................32518.1.4.1. 18.1.4.2. OBJETOS Pen ...........................................................................................................325 OBJETOS Brush ......................................................................................................325

18.1.5. 18.1.6. 18.1.7.

CANETAS E PINCIS PADRONIZADOS ....................................................326 OPERAES DE DESENHO..........................................................................326EXERCCIO: DESENHANDO FORMAS SIMPLES...............................................327 EXERCCIO: MANIPULANDO EVENTOS Paint E INTERAGINDO COM O 329

18.1.6.1. 18.1.7.1. MOUSE

EVENTOS Paint..............................................................................................329

18.1.8. 18.1.9. 18.2. 18.3. 18.4.

USANDO CORES ..............................................................................................331 USANDO FONTES ............................................................................................332EXERCCIO: CRIANDO E USANDO UMA Font.................................................332 EXERCCIO: CRIANDO UMA LISTA PARA TEXTO ..........................................334 EXERCCIO: MOSTRANDO UM BITMAP EM UMA FORMA............................336 EXERCCIO: USANDO A FUNCIONALIDADE DE IMPRESSORA DENTRO DA 337

18.1.9.1. 18.1.9.2. 18.2.1.1. 18.3.1.1. GDI+

MANIPULANDO IMAGENS.................................................................................336 IMPRESSES.........................................................................................................337 RPIDAS REFERNCIAS SOBRE O CAPTULO 18........................................340 ix

19.

CAPTULO 19: TRABALHANDO COM ARQUIVOS...............................341

19.1. O namespace System::IO ........................................................................................341 19.2. I/O DE TEXTO USANDO LEITORES E ESCRITORES ....................................342 19.2.1. USANDO TextWriter ........................................................................................34219.2.1.1. EXERCCIO: ESCREVENDO DADOS DE CARACTERES PARA UM ARQUIVO DE TEXTO ...................................................................................................................................343

19.2.2. 19.2.3.

A CLASSE FileStream .................................................................................344 USANDO TextReader........................................................................................345EXERCCIO: PROGRAMA SIMILAR AO UNIX more..........................................345

19.2.3.1.

19.3. TRABALHANDO COM ARQUIVOS E PASTAS .................................................347 19.3.1. OBTENDO INFORMAES SOBRE ARQUIVOS E PASTAS .................34819.3.1.1. EXERCCIO: USANDO AS CLASSES DE MANIPULAO DE PASTAS E ARQUIVOS..................................................................................................................................350

19.4. I/O BINRIA...........................................................................................................355 19.4.1. A CLASSE BinaryWriter..................................................................................355 19.4.2. A CLASSE BinaryReader .................................................................................35519.4.2.1. EXERCCIO: USANDO AS CLASSES BinaryReader E BinaryWriter .....356

19.5.

RPIDAS REFERNCIAS SOBRE O CAPTULO 19........................................360

x

INTRODUO Desde a sua introduo em 2002, as pessoas tm concentrado suas atenes nas diversas caractersticas novas que constituem parte do Microsoft .NET, tais como a principal mudana para o Microsoft Visual Basic, a introduo do C#, os novos modelos ASP.NET e ADO.NET, e o crescente uso do XML. Os desenvolvedores de C++ no precisam se sentir esquecidos pois uma substancial quantidade de novas caractersticas no Microsoft Visual C++ .NET torna o C++ um membro de primeira classe da famlia .NET de linguagens de programao. Este livro lhe fornece uma introduo s novas caractersticas especficas .NET que a Microsoft adicionou ao Visual C++ para suportar desenvolvimento .NET e ser completamente atualizado para se livrar do Microsoft .NET Framework 1.1. Esta nova funcionalidade chamada de Extenses Gerenciadas para C++ e, alm de suprir os programadores C++ com acesso a toda a funcionalidade das bibliotecas de classe .NET, ela tambm permite operaes com cdigos C++, objetos COM e APIs Win32 existentes. REQUERIMENTOS DO SISTEMA Para completar os exerccios neste livro, voc precisar ter o Microsoft Visual Studio .NET instalado. O Visual Studio .NET est disponvel em vrias edies; Voc precisar de uma das seguintes: Visual C++ .NET Standard; Visual Studio .NET Professional; Visual Studio .NET Enterprise

A menos que voc tenha comprado este livro como parte da edio de luxo de aprendizagem do Visual Studio .NET, o software Visual Studio .NET no est includo no livro. Voc deve comprlo separadamente e instal-lo antes de iniciar os exerccios deste livro. Voc tambm precisar de um computador capaz de executar o Visual Studio .NET. Para detalhes completos, verifique o pacote de produtos ou a pgina eletrnica do Microsoft Visual Studio (http://msdn.microsoft.com/vstudio). INSTALANDO E USANDO OS ARQUIVOS PARA PRTICA O CD que acompanha este livro contm os arquivos para prtica que voc usar como exerccios no livro. Usando os arquivos para prtica voc no perder tempo para criar objetos que no sejam relevantes para um dado exerccio. Assim, ter mais tempo para se concentrar em aprender a programao orientada para objetos com as extenses gerenciadas para C++. Os arquivos e as instrues passo-a-passo nas lies tambm o direcionam a aprender fazendo, o que um modo fcil e efetivo para adquirir e relembrar novas habilidades. IMPORTANTE: Antes de quebrar o selo no pacote do CD de acompanhamento, assegure-se de que este livro corresponde verso do software. Este livro foi projetado para uso com o Microsoft Visual Studio .NET para sistemas operacionais do Microsoft Windows. Para descobrir qual o software que voc est executando, verifique o pacote do produto ou inicialize o software e, ento, clique em About Microsoft Development Environment no menu Help no topo da tela. xi

Instalando os Arquivos para prtica Siga os passos abaixo para instalar os arquivos para prtica no disco rgido do seu computador para que voc possa utiliz-los com os exerccios deste livro: PASSO 1: Insira o CD de acompanhamento no drive de CD-ROM do seu computador. IMPORTANTE: Em alguns computadores, a tela do menu de inicializao pode aparecer automaticamente quando voc fechar o drive de CD-ROM. Neste caso, siga as instrues na tela, pulando os PASSOs 2, 3 e 4. PASSO 2: No menu Start, clique em My Computer ou d um clique duplo no cone My Computer no desktop; PASSO 3: D um clique duplo no cone do drive de CD-ROM do seu computador; PASSO 4: D um clique duplo em StartCD.exe. Uma tela de menu de inicializao aparece com as opes que lhe permitem ver, navegar e instalar os contedos do CD-ROM, alm de acessar a pgina eletrnica da Microsoft Press para suporte tcnico. PASSO 5: Clique em Install Practice Files. Clique ok na caixa de mensagens inicial. A janela de configurao do programa aparece com as opes recomendadas pr-selecionadas para voc. Para otimizar os resultados no uso dos arquivos para prtica com este livro, aceite a configurao prselecionada. Uma pasta chamada Microsoft Visual C++ .NET Step By Step foi criada em Meus Documentos, e os arquivos para prtica foram ali colocados. Desinstalando os Arquivos para Prtica Siga os passos abaixo para remover os arquivos para prtica do seu computador. Estes passos foram escritos para o sistema operacional Windows XP Profissional. Se voc estiver usando uma verso diferente do Windows, use as referncias da documentao de ajuda do Windows para remover programas. PASSO 1: Clique Iniciar Painel de Controle; PASSO 2: No Painel de Controle, d um clique duplo em Adicionar ou Remover Programas; PASSO 3: Na janela Adicionar ou Remover Programas, clique em Microsoft Visual C++ .NET Step By Step na lista Programas e Atualizaes Instalados; PASSO 4: Clique em Alterar/Remover. Aparece a caixa de dilogo Confirmar Desinstalao. Clique Sim para deletar os arquivos para prtica. CONVENES E CARACTERSTICAS NESTE LIVRO Este livro apresenta informaes usando convenes projetadas para tornar mais legvel a informao e mais fcil as conexes entre os tpicos. O livro tambm inclui caractersticas que contribuem para estudo mais aprofundado do material. Convenes xii Cada exerccio constitui uma srie de tarefas. Cada tarefa apresentada como uma srie de passos rotulados. Se uma tarefa tiver apenas um passo, este indicado por um ponto. As notas rotuladas por DICAS fornecem mais informaes para completar um passo com sucesso.

As notas rotuladas por IMPORTANTE chamam a sua ateno para informaes que precisam ser verificadas antes de continuar o estudo. O texto que voc deve digitar aparece em negrito. Os termos so mostrados em itlico quando so definidos. Um sinal mais (+) entre dois nomes de tecla significa que voc deve pressionar estas pressionar estas teclas ao mesmo tempo. Por exemplo, Alt + Tab significa que voc deve manter Alt pressionada enquanto pressiona Tab.

Outras Caractersticas deste Livro Voc pode aprender tcnicas especiais, informaes bsicas ou caractersticas relacionadas com a informao que estiver sendo discutida lendo as barras laterais sombreadas que aparecem ao longo das lies. Estas barras laterais freqentemente realam terminologia difcil ou sugerem futuras reas para explorao. Voc pode obter uma lembrana rpida de como realizar as tarefas que aprendeu lendo as REFERNCIAS RPIDAS no final da lio. CORREES, COMENTRIOS E AJUDA Todo o esforo foi feito para assegurar a preciso deste livro e dos contedos dos arquivos para prtica no CD. A Microsoft Press fornece correes e contedos adicionais para seus livros atravs da pgina http://www.microsoft.com/mspress/support/. Se voc tiver problemas, comentrios ou idias relativas a este livro ou ao CD de acompanhamento, por favor as envie para a Microsoft Press, email mspinput@microsoft.com, ou para o endereo postal Microsoft Press Attn: Step by Step Series Editor One Microsoft Way Redmond, WA 98052-6399 Por favor, note que o suporte para o software Visual Studio .NET no oferecido atravs dos endereos acima. Para ajuda a respeito do Visual Studio .NET, visite http://support.microsoft.com. VISITE A PGINA ELETRNICA DA MICROSOFT PRESS Voc tambm convidado a visitar a pgina da Microsoft Press, www.microsoft.com/mspress. Ali voc encontrar descries para a linha completa dos livros da Microsoft Press, informaes sobre a compra de ttulos, notcias sobre caractersticas e eventos especiais, contedos adicionais para livros da Microsoft Press, e muito mais. Voc tambm pode encontrar os desenvolvimentos mais recentes do Visual Studio .NET e as notcias sobre a Microsoft Corporation visitando http://msdn.microsoft.com/vstudio/nextgen.

xiii

PARTE 1: INICIALIZAO EM C++ .NET 1. HELLO, C++!

Neste captulo, voc aprender como Reconhecer caractersticas C++; Reconhecer funes C++; Reconhecer palavras-chaves e identificadores C++; Criar um programa C++.

Bem-vindo ao excitante mundo da programao .NET com o Microsoft Visual C++. Este captulo introduz a linguagem C++ e entradas/sadas simples (input/output = I/O) usando as flexibilidades do console da biblioteca padro C++.

1.1.

O QUE UM PROGRAMA C++?

Bem, um programa C++ contm exatamente os mesmos elementos de qualquer outro programa de computador dados para armazenar suas informaes e blocos de cdigo que manipulam estes dados. Se voc j tem experincia com o Microsoft Visual Basic ou com o velho COBOL dos anos 1940, os elementos bsicos lhe sero familiar. Muitos mistrios cercam a prtica de programao C++, mas a maioria deles no se justifica e desnecessria. Vamos comear com algumas regras fundamentais para C++.

1.1.1.

C++ UMA LINGUAGEM FORTEMENTE VINCULADA A TIPOS

Se voc tiver uma varivel que foi declarada com capacidade de armazenar mas, nela voc so pode armazenar mas. Porm, esta exigncia no to severa quanto soa. C++ contm muitas caractersticas para fornecer converses implcitas onde for necessrio. Esta intensa checagem de tipo elimina muitos bugs comuns em programao porque ela explicitamente probe quaisquer converses entre tipos de dados que possam resultar em perda de dados.

1.1.2.

C++ UMA LINGUAGEM EFICIENTE

Se voc escreve cdigos que precisam executar rapidamente (por exemplo, cdigos de procura em listas ou que realizam clculos matemticos com complexos), C++ pode ser a sua linguagem escolhida.

1.1.3.

C++ UMA LINGUAGEM ORIENTADA PARA OBJETOS

Programadores modernos gostam das muitas vantagens da programao orientada para objetos (veja o captulo 2 para mais informaes sobre programao orientada para objetos). C++ uma das primeiras linguagens de programao orientada para objetos.

14

1.1.4.

C++ BASEADA EM C (COMO VOC J SUSPEITAVA)

C uma linguagem bem estabelecida. C++ inclui algumas caractersticas estranhas para manter sua compatibilidade com C, mas provavelmente ela no seria to popular sem esta compatibilidade.

1.1.5.

C++ UMA LINGUAGEM SENSVEL A CARACTERES MAISCULOS E MINSCULOS

Se o compilador lhe adverte sobre uma varivel no declarada, provavelmente voc digitou um caractere maisculo ao invs de um minsculo (ou vice-versa).

1.2.

SEU PRIMEIRO PROGRAMA C++

Agora vamos sujar nossas mos com um programa C++ simples. Naturalmente, nenhum livro sobre C++ estaria completo sem incluir o famoso programa Hello, World. Assim, vamos comear com ele.#include using namespace std; int main()//************************************************************** { cout GetName()); Console::Write("N de Pernas: "); Console::WriteLine(cat->legs); Console::WriteLine(); Console::WriteLine("Animal 2"); Console::Write("Nome: "); Console::WriteLine(dog->GetName()); Console::Write("N de Pernas: "); Console::WriteLine(dog->legs); Console::WriteLine(); return 0; }//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

PASSO 5: Construa o aplicativo. Selecione o menu Build Build Solution ou use Ctrl + Shift + B. 32

No caso de voc ter problemas ao juntar os fragmentos nos passos do programa, eis o programa inteiro:// This is the main project file for VC++ application project // generated using an Application Wizard. #include "stdafx.h" #using using namespace System; __gc class Animal//+++++++++++++++++++++++++++++++++++++++++++++++++++++++ { public: int legs; void SetName(String *name)//-----------------------------------------{ strName = strName->Copy(name); }//------------------------------------------------------------------String* GetName()//--------------------------------------------------{ return strName; }//------------------------------------------------------------------private: String *strName; };//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ int _tmain()//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ { Animal *cat, *dog; cat = new Animal; dog = new Animal; cat->SetName("Gato"); cat->legs = 4; dog->SetName("Cachorro"); dog->legs = 4; Console::WriteLine("Animal 1"); Console::Write("Nome: "); Console::WriteLine(cat->GetName()); Console::Write("N de Pernas: "); Console::WriteLine(cat->legs); Console::WriteLine(); Console::WriteLine("Animal 2"); Console::Write("Nome: "); Console::WriteLine(dog->GetName()); Console::Write("N de Pernas: "); Console::WriteLine(dog->legs); Console::WriteLine(); return 0; }//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

PASSO 6: Se a construo foi bem sucedida, execute o aplicativo selecionando o menu Debug Start Without Debugging ou use Ctrl + F5. A Figura 2.2 mostra o resultado. 33

Figura 2.2: Console do programa Animals.

2.6.

RPIDAS REFERNCIAS SOBRE O CAPTULO 2

A Tabela 2.1 mostra um resumo do que estudamos neste captulo. Tabela 2.1: Resumo do captulo 2.PARA Criar uma classe Controlar a visibilidade de variveis e mtodos Declarar uma classe de tipo de referncia Declarar uma classe de tipo de valor Instancializar um objeto de classe do tipo de referncia FAA ISTO Use a palavra-chave class Use as palavras-chaves para controle private ou protected, seguidas de : de acesso public,

Coloque a palavra-chave __gc antes do especificador da classe

Coloque a palavra-chave __value antes do especificador da classe Declare um ponteiro do tipo de classe para o objeto. Use a palavra-chave new seguida pelo nome da classe para criar o objeto na heap CLR e nomeie o ponteiro retornado para ponteiro do objeto declarado acima. Por exemplo: HeapClass *pObject1; pObject1 = new HeapClass; Instancializar um Defina o objeto class + nome da varivel. Por exemplo: objeto de classe do ValueClass object1; tipo de valor

34

3.

CAPTULO 3: VARIVEIS E OPERADORES

Neste captulo, voc aprender como: Declarar (criar) variveis; Usar tipos de dados embutidos C++; Criar tipos definidos pelo usurio; Adicionar variveis-membros a uma classe; Usar a classe String do Microsoft .NET Framework; Atribuir valores a uma varivel; Criar expresses usando os operadores C++; Moldar (mudar) o tipo de uma varivel.

No captulo anterior, falamos um pouco sobre as vantagens da programao orientada para objetos e desenvolvemos um programa simples para ilustrar a criao e o uso de classes. Neste captulo, veremos com mais detalhes como criar e usar variveis, os tipos de dados fundamentais em C++, como acessar e usar classes do .NET Framework e como criar expresses usando os operadores C++.

3.1.

O QUE UMA VARIVEL?

Variveis so locais na memria onde os dados podem ser temporariamente armazenados para uso pelo programa. Elas tm um nome, um tipo e um valor. O valor da varivel pode ser mudado durante a execuo do programa. Da o nome varivel. Uma varivel deve ser declarada antes de ser usada: seu tipo tem que ser especificado e a ela deve ser atribudo um nome. O tipo de uma varivel define o intervalo vlido dos valores que o tipo pode suportar e as operaes que podem ser realizadas na varivel.

3.2.

OS TIPOS FUNDAMENTAIS DE DADOS

A Tabela 3.1 mostra o conjunto dos tipos de dados embutidos no C++. Destes tipos embutidos, voc pode construir outros tipos, como veremos neste captulo: Tipos ponteiros, por exemplo, int*; Tipos matrizes, por exemplo, int[]; Tipos Referncias, por exemplo, double&.

Voc tambm pode construir tipos definidos pelo usurio criando estruturas de dados e classes. As classes so abordadas no captulo 5.

35

Tabela 3.1: Tipos de dados embutidos em C++.TIPO bool char short int DESCRIO COMENTRIOS Um tipo booleano que pode conter os valores true e false. Um tipo caractere que pode Os valores variam de 128 a 127. suportar valores ASCII. Inteiro; armazena o nmero Os valores variam de -32768 a 32767. completo. Inteiro; armazena o nmero Os valores variam de -2147483648 a completo. 2147483647. Um unsigned int varia de 0 a 4294967295 (232 1). Inteiro com int, exceto que em No Microsoft Visual C++, o long tem alguns compiladores, ele tem o mesmo tamanho do int. E, portanto, ele s pode armazenar o mesmo tamanho duplicado. intervalo de valores. Um tipo de inteiro especfico da Microsoft, equivalente ao tipo de dados char Um tipo de inteiro especfico da Microsoft, equivalente ao tipo de dados short Um tipo de inteiro especfico da Microsoft, equivalente ao tipo de dados int Um tipo de inteiro especfico da Valores no intervalo de 264/2 a Microsoft que armazena o nmero 264/2 1. completo Armazena nmeros de ponto- No Visual C++, o float armazena at flutuante, por exemplo, 3.7 7 casas decimais. O intervalo de valores 3.4E+/-38. Armazena nmeros de ponto- O double armazena at 15 casas flutuante como float mas com decimais. O intervalo de valores 1.7E+/-308. maior preciso Um tipo caractere largo ou tipo caractere multibyte

long

__int8

__int16

__int32

__int64

float

double

wchar_t

3.3.

DECLARANDO UMA VARIVEL

Como mencionamos antes, as variveis devem ser declaradas antes de serem usadas. Uma declarao simples consiste deUm tipo + um ou mais nomes de variveis separados por vrgulas + ponto-e-vrgula no final.

Por exemplo:int double nPrimeNumber; x, y, z;

Cada varivel pode receber um qualificador antes do tipo (por exemplo, unsigned). Voc tambm pode colocar um inicializador aps o nome da varivel para fornec-lo um valor inicial (por exemplo, int i = 0;). O qualificador e o inicializador so opcionais e no precisam aparecer na declarao, mas o tipo base e o nome da varivel devem estar presentes. A declarao termina em ponto-e-vrgula.[qualificador] tipo nome [inicializador];

Por exemplo:unsigned int i; //Uma varivel inteiro sem sinal i. Note o //qualificador limitando a varivel a nmeros //positivos.

36

long double

lSalario = 0; y;

//Uma varivel long inicializada com zero. //Uma varivel double sem qualificador ou //inicializador.

A declarao da varivel permite que o compilador: Aloque memria suficiente para armazenar a varivel de um dado tipo e para associar o nome da varivel com esta localizao de memria. Reserve o nome da varivel para preveni-lo se houver uso do mesmo nome para outras variveis dentro do mesmo escopo. NOTA: Escopo se refere parte do cdigo onde a varivel visvel i.e., onde pode ser usada. O conceito de escopo explicado com mais detalhe no captulo 4. Garante que a varivel usada de uma maneira consistente com seu tipo. Por exemplo, se voc tiver declarado uma varivel como char, no poder armazenar nela o valor 3.7.

3.3.1.

NOMEANDO VARIVEIS

Um nome de varivel em C++ pode ser qualquer combinao de letras, nmeros e sublinhados, contanto que o primeiro caractere da varivel seja uma letra ou um sublinhado. Embora o C++ no tenha quaisquer restries nossa escolha dos nomes das variveis, voc deve usar nomes significativos e ser consistente nas suas convenes de nomear variveis para melhorar a legibilidade do seu cdigo. O C++ sensvel notao maiscula/minscula, i.e., letras maisculas so consideradas diferentes das suas similares minsculas. Por exemplo, myvariable e myVariable so variveis diferentes. Porm, no boa idia diferenciar variveis apenas com base na sua grafia; isto pode confundi-lo em leitura posterior do cdigo. No raro digitarmos, por acidente, uma letra minscula ao invs de uma maiscula ou vice-versa. NOTA: Como mencionamos no captulo 1, no uma boa idia criar identificadores que comeam com dois sublinhados ou um sublinhado seguido por uma letra maiscula (por exemplo, _A). Isto porque a Microsoft usa esta conveno de nomes para especificar macros e palavras-chaves especficas dela. Assim, comear suas variveis com estas combinaes pode levar a conflitos de nomes.

3.4.

DECLARANDO MLTIPLAS VARIVEIS

Voc pode declarar diversas variveis do mesmo tipo na mesma linha simplesmente separando-as com vrgula:int x = 10, y, z = 11;

Esta declarao cria trs inteiros chamados x, y e z. O primeiro inteiro inicializado com 10 e o terceiro com 11, enquanto o segundo no inicializado.

3.5.

NOMEANDO VALORES PARA AS VARIVEIS

Voc nomeia um valor para uma varivel usando o operador de atribuies = (um sinal igual). O valor no lado direito do operador armazenado na varivel do lado esquerdo. Quando atribuir um valor para uma varivel, o valor deve pertencer ao mesmo tipo da varivel, ser um tipo para o qual

37

C++ possa realizar uma converso de atribuio (tal como entre float e tipos inteiros), ou ser convertido explicitamente para o tipo correto. CONVERSES DE ATRIBUIO As converses de atribuio ocorrem quando variveis de lados opostos de um sinal igual so de tipos diferentes e o compilador pode converter entre os dois tipos sem qualquer possibilidade de perda de dados. Por exemplo, atribuir um inteiro para um double resultar em uma converso de atribuio onde tudo que o compilador tem que fazer adicionar .0 ao inteiro. Ocasionalmente voc pode precisar dizer ao compilador que realize uma converso que de outro modo ele no faria. Por exemplo, a diviso de dois inteiros resulta em um inteiro. Se voc quiser um resultado ponto-flutuante, pode forar o compilador a converter um dos valores para double, como no exemplo:double result = double(640) / 480;

Voc d o nome do tipo para o qual o resultado deve ser convertido, seguido pelo valor entre parnteses. Este processo chamado de molde (casting), e ele pode ser bastante perigoso porque voc est dizendo ao compilador para aplicar uma converso e, portanto, deve estar seguro de que est agindo corretamente. Por exemplo:int float double x = 1; z = x; y = 3.56; x = y; x; y; z;

//Esta converso de float para int resulta em perda de dados. //O inteiro 3 armazenado na varivel x.

O compilador ir gerar a advertncia C4244: = conversion from float to int possible loss of data. A razo para isto que a atribuio de 3.56 para inteiro provocar a perda da parte decimal, i.e., truncar o resultado em 3.

3.6.

MATRIZES

Uma matriz uma coleo de locais para armazenamento de dados, todos do mesmo tipo por exemplo, int ou double. As matrizes so teis quando voc quer representar uma coleo de valores, como o nmero de dias em cada ms ou os nomes dos empregados de uma companhia. Cada local de armazenamento chamado de um elemento da matriz. Os elementos da matriz so acessados referenciando a partir de um offset o nome da matriz. Os elementos da matriz comeam de zero at o tamanho da matriz menos 1:int nArray[10]; int x; nArray[0] = 23; nArray[9] = 21; x = nArray[0]; //Declarao de uma matriz com 10 inteiros

//O 1 elemento na matriz comea no offset 0 //O ltimo elemento na matriz comea no offset 9

Escrever dados alm do fim da matriz constitui um srio problema e a causa de muitos bugs em programas C++. Quando acessa um elemento da matriz, o compilador calcula sua posio em relao ao incio da matriz. Se voc estiver escrevendo para um elemento de matriz e der um ndice invlido 38

de modo que o offset calculado esteja aps o fim da matriz, o compilador sobrescrever tudo o que estiver naquele local de memria.

3.7.

PONTEIROS

Um ponteiro uma varivel que retm o endereo da memria de outra varivel ou funo, o que significa que voc pode usar um ponteiro para se referir indiretamente a uma varivel. NOTA: Por que os ponteiros so teis? A mais pragmtica razo para usar ponteiros consiste em sabermos que eles fazem parte da famlia C de linguagens diretas desde o incio e so extensivamente usados. Assim, voc precisar conhecer alguma coisa sobre eles. Entretanto, h muitas outras razes. Resumiremos a seguir duas delas. A primeira: ponteiros so um dos modos principais de passar argumentos para as funes. Os argumentos so usualmente passados por valor como uma cpia. Assim voc no pode modificar o valor e obt-lo de volta para o cdigo aps a funo. Os ponteiros permitem que voc passe argumentos para uma funo de tal modo que pode modific-los dentro desta. A segunda razo: Algumas operaes em sries de dados como, por exemplo, em matrizes podem ser realizadas muito eficientemente usando ponteiros. Embora uma varivel-ponteiro contenha um endereo e, portanto, pode armazenar um endereo de memria de qualquer tipo de dados, as variveis-ponteiros so declaradas para ser tipo de dados especficos. Um ponteiro para um tipo de dados inteiros (int) no armazena o endereo de um double. A varivel-ponteiro declarada do mesmo modo que as variveis de tipo de dados, mas o operador de ponteiro * (um asterisco) anexado ao tipo de dados:int* double* char* pi;//Ponteiro para um int pd;//Ponteiro para um double pc;//Ponteiro para char

Toda varivel tem um endereo e este endereo pode ser obtido usando o operador de endereo &. O endereo da varivel pode ser armazenado em uma varivel-ponteiro e, usando este ponteiro, os contedos da varivel podem ser manipulados atravs do operador de desreferncia * (tambm um asterisco):int x = 10, y = 0; int* pX = NULL; pX = &x; y = *pX; *pX = 20; //Declara um ponteiro. //Armazena o endereo da varivel inteira x. //Atribui o valor de x para y. //Atribui o valor 20 para x.

Nas duas ltimas linhas do cdigo acima, *pX pode ser lido como o valor que pX aponta. NOTA: Pode parecer confuso que o operador asterisco seja usado tanto como o operador de ponteiro quanto como operador de desreferncia. Porm, voc s encontrar o operador de ponteiro nas declaraes de variveis, enquanto o operador de desreferncia usado no cdigo. Assim, torna-se bvio saber qual operador um dado asterisco representa.

3.8.

REFERNCIAS

Uma varivel-referncia um apelido para outra varivel. Todas as variveis-referncias devem ser inicializadas quando declaradas. Da em diante, qualquer mudana feita na varivel-referncia tambm afetar a varivel apelidada. As variveis-referncias so particularmente importantes quando 39

passamos variveis para funes, tpico abordado com mais detalhes posteriormente. Por enquanto, eis um exemplo:int x = 10; int& y = x; y = 4; //Declara y como referncia para x. //O valor de x tambm muda para 4.

3.9.

CONSTANTES

Como as variveis, as constantes so locais nomeados para armazenamento de dados. Porm, ao contrrio de uma varivel, o valor de uma constante no pode ser mudado aps sua declarao. Uma constante tem que ser inicializada quando criada e no lhe pode ser atribudo outro valor posteriormente. O C++ tem dois tipos de constantes: literal e simblica.

3.9.1.

CONSTANTE LITERAL

Uma constante literal simplesmente um valor digitado no programa. As declaraes no cdigo abaixo atribuem as constantes literais 40 e Dog para as respectivas variveis NoOfEmployees e strName:NoOfEmployees = 40; strName = Dog;

3.9.2.

CONSTANTE SIMBLICA

uma constante representada por um nome. Ela definida exatamente do mesmo modo que uma varivel, mas o qualificador deve comear com a palavra-chave const e a varivel deve ser inicializada. Aps a declarao, o nome da constante pode ser usado em qualquer lugar permissvel para uma varivel do seu tipo, como mostrado abaixo:const unsigned long NoOfFullTimeEmployees = 49; const unsigned long NoOfPartTimeEmployees = 234; unsigned int NoOfEmployees; NoOfEmployees = NoOfFullTimeEmployees + NoOfPartTimeEmployees;

H uma dupla vantagem em usar constantes simblicas ao invs de constantes literais: Os nomes simblicos tornam o programa mais legvel. A constante NoOfFullTimeEmployees mais significativa do que a constante literal 49. simblica

mais fcil mudar uma nica declarao de constante simblica do que encontrar e substituir todas as ocorrncias de uma constante literal em um programa.

Porm, o uso de constantes simblicas no lugar de constantes literais pode ser muito trabalhoso. No h necessidade de substituir todas as constantes literais por simblicas. H algumas constantes que so intuitivamente bvias para qualquer pessoa e que no mudaro. Por exemplo, o nmero de dias em uma semana ou os meses do ano. Estes valores podem ser deixados literalmente sem reduo da legibilidade ou manuteno do cdigo.

3.10.

ENUMERAES

Em situaes onde uma varivel s pode assumir um conjunto especfico de valores, tais como cores ou gneros, as enumeraes permitem que voc crie novos tipos e declare variveis cujos valores so restritos ao conjunto enumerado. 40

As enumeraes so declaradas da seguinte maneira:enum + nome do tipo + { + os valores enumerados separados por vrgulas + } + um ponto-e-vrgula

Ento, as variveis so declaradas como um tipo enumerado e elas s podem receber um dos valores enumerados. Por exemplo:enum WorkDays {Monday, Tuesday, Wednesday, Thursday, Friday}; const int Saturday = 7; WorkDays WorkingDay; WorkingDay = Thursday; //Thursday um membro do tipo enumerado //WorkDays e, portanto, pode ser nomeado //para a varivel WorkingDay. WorkingDay = Saturday; //Embora Saturday seja uma constante inteira, //ela no membro do tipo enumerado WorkingDay //e, portanto, no pode ser nomeada para a //varivel WorkingDay.

3.11.

TIPOS DEFINIDOS PELO USURIO

typedef sinnimo de tipo definido pelo usurio para um tipo existente. Para criar um sinnimo para um dado tipo:typedef + nome do tipo + o novo nome que voc quer usar + ponto-e-vrgula

Por exemplo:typedef unsigned int positiveNumber;

Este typedef declara positiveNumber como sinnimo de unsigned int e, a partir de ento, voc pode fazer declaraes como:positiveNumber one, two;

3.12.

ADICIONANDO VARIVEIS-MEMBROS S CLASSES

PASSO 1: Entre no Microsoft Visual Studio .NET e selecione File New Project. Aparece a caixa de dilogo New Project. PASSO 2: Em Project Type, escolha Visual C++ Projects e em Templates escolha Console Application (.NET). Na caixa de texto Name, digite Variables e escolha uma localizao para o seu novo projeto no disco rgido. Clique OK. PASSO 3: Clique no menu Project Add Class. Aparece na tela a caixa de dilogo Add Class (Figura 3.1). PASSO 4: Em Templates, escolha Generic C++ Class. Clique Open. Surge, ento, a caixa de dilogo Generic C++ Class Wizard (Figura 3.2). PASSO 5: Na caixa de texto Class name, digite Animal. Note como os nomes padres para os arquivos de cabealho e fonte so criados automaticamente. PASSO 6: Deixe a caixa de texto Base class em branco. PASSO 7: Na lista Access, selecione public (note que public o modificador de acesso padro. Assim, ele j est selecionado). PASSO 8: Marque a caixa de checagem Virtual destructor. 41

Figura 3.1: Caixa de dilogo Add Class.

Figura 3.2: Caixa de dilogo Generic C++ Class Wizard. PASSO 9: Clique Finish. Note que o arquivo de cabealho para a nova classe, Animal.h, foi carregado na janela principal. No Solution Explorer, o arquivo Animal.cpp foi adicionado pasta Source Files e o arquivo de cabealho, Animal.h, foi adicionado pasta Header Files (Figura 3.3). Na janela Class View, se voc expandir o n Variables, ver que a nova classe Animal foi adicionada ao projeto. Se expandir a classe Animal, voc ver o construtor, Animal(void), e o destrutor, ~Animal(void), padres para a classe (Figura 3.4).

42

Figura 3.3: Janela principal do Visual Studio .NET, mostrando o contedo do arquivo de cabealho Animal.h e do Solution Explorer.

Figura 3.4: Janela principal do Visual Studio .NET, mostrando o contedo do Animal.h e da janela Class View.

PASSO 10: Na janela Class View, expanda o n Variables, clique com o boto direito do mouse na classe Animal, selecione Add Add Variable (Figura 3.5). Surge a caixa de dilogo Add Member Variable Wizard (Figura 3.6). Aceite o modificador de acesso padro, public.

Figura 3.5: Adicionando nova varivel classe Animal. PASSO 11: No menu drop-down Variable type, selecione int. 43

PASSO 12: Na caixa de texto Variable name, digite legs. PASSO 13: Clique Finish.

Figura 3.6: Caixa de dilogo Add Member Variable Wizard. A Figura 3.7 mostra o arquivo-fonte Animal.cpp e a janela Class View expandida.

Figura 3. 7: Janela principal do Visual Studio .NET, mostrando o contedo do Animal.c e da janela Class View.

Neste exerccio, voc viu como criar uma nova classe usando o Visual Studio e como adicionar membros a esta classe.

3.13.

A CLASSE String DO .NET FRAMEWORK

A classe String no um tipo embutido de dados como int ou long, mas faz parte do .NET Framework. Por no ser um tipo embutido, voc tem que incluir alguns arquivos no seu projeto antes 44

de compilar e utilizar a classe String. Qualquer cdigo que utilize a classe String ter que incluir as duas linhas abaixo no topo do cdigo do arquivo-fonte:#using using namespace System;

A linha #using diz ao compilador para procurar no arquivo mscorlib.dll os detalhes da classe String. mscorlib.dll o arquivo de biblioteca que contm a essncia dos componentes .NET e voc o encontrar com bastante freqncia ao longo deste livro. A segunda linha facilita o uso de algumas classes .NET. Por enquanto, apenas a digite no incio dos arquivos-fontes que utilizem a classe String. A classe String contm um grande nmero de mtodos que simplificam a manipulao de strings, como, por exemplo, Insert e Replace. NOTA: Embora a classe String seja muito poderosa, uma vez que voc inicialize um objeto String, ele se torna imutvel, i.e., voc no pode alter-lo aps a criao. As funes-membros da classe String que parecem alterar strings, como, por exemplo, Insert e Replace, na verdade retornam um novo objeto String, que contm a string modificada. Este comportamento torna muito ineficientes os mtodos da classe String quando precisamos realizar repetidas modificaes em uma string. Se voc precisar fazer tais mudanas repetidamente em uma string, deve usar a classe StringBuilder. Neste caso, voc ter que incluir o conjunto (assembly) mscorlib.dll e o namespace System::Text para simplificar o acesso aos membros.

3.14.

OPERADORES E EXPRESSES

Expresses so construes que usam operadores que lidam com dados os operandos para obter um resultado. Veja o exemplo abaixo:Remuneration = Salary + Bonus;

Acima, o operador de adio + (um sinal mais) usado para adicionar os operandos Salary e Bonus, e o operador de atribuio = (um sinal igual) usado para armazenar o total na varivel Remuneration.

3.14.1.

OPERADORES DE ATRIBUIO

Um operador de atribuio usado para nomear um valor para uma varivel. Todas as expresses retornam um valor quando avaliadas e o valor da expresso de atribuio o novo valor do objeto no lado esquerdo. Esta funcionalidade permite a nomeao do mesmo valor para um grupo de variveis.NoOfMammals = NoOfDogs = NoOfCats = 0;

Neste exemplo, todas as trs variveis NoOfMammals, NoOfDogs e NoOfCats so fixados para 0.

3.14.2.3.14.2.1.

OPERADORES ARITMTICOSOPERADORES MATEMTICOS PADRES

C++ tem 12 operadores aritmticos, 5 dos quais operam como os operadores matemticos padres: o operador de adio + (um sinal mais); 45

o de subtrao (um sinal menos); o de multiplicao * (um asterisco); o de diviso / (uma barra) e o operador de mdulo % (um sinal de porcentagem), que retorna o resto de uma diviso.

Por exemplo:Result = 4 + 2 - 3; //Result = 3 Result = 4 * 5; //Result = 20 Reminder = 7 % 3; //Reminder = 1

3.14.2.2.

OPERADORES ARITMTICOS DE ATRIBUIO

Alm dos operadores matemticos usuais, h alguns operadores aritmticos de atribuio: o operador de atribuio de adio += (um sinal mais seguido de um sinal igual); o operador de atribuio de subtrao = (um sinal menos seguido de um sinal igual); o operador de atribuio de multiplicao *= (um asterisco seguido de um sinal igual); o operador de atribuio de diviso /= (uma barra seguida de um sinal igual) e o operador de atribuio de mdulo %= (um sinal de percentagem seguido de um sinal igual).

Estes operadores so formas taquigrficas que combinam a operao matemtica correspondente com a operao de atribuio. Assim, A = A + 5; pode ser expressa como A += 5;. Ao invs de usar o operador de adio para adicionar 5 ao valor da varivel A e, ento, usar o operador de atribuio para nomear o novo valor para a varivel A, voc s precisar usar o operador de atribuio de adio para adicionar 5 ao valor da varivel A e nomear o novo valor. O operador de atribuio de adio um operador de compactao. No h diferena entre as duas declaraes. Em ambas, uma adio realizada, seguida por uma atribuio. A segunda forma apenas uma maneira compactada de expressar uma operao usada com freqncia.

3.14.2.3.

OPERADORES DE INCREMENTO E DECREMENTO

Os operadores de incremento e decremento so similares aos operadores taquigrficos, sendo que o operador de incremento adiciona apenas 1 ao valor da varivel e o de decremento subtrai 1:A++; A--; //Adiciona 1 ao valor da varivel A //Subtrai 1 ao valor da varivel A

H duas formas para os operadores de incremento e decremento: a forma prefixada: ++A ou A e a forma ps-fixada: A++ ou A--;

Ambas as formas adicionam ou subtraem 1 ao valor da varivel. Na forma prefixada, a operao matemtica realizada antes que a varivel seja usada na expresso; na ps-fixada, a varivel incrementada ou decrementada aps ter sido usada na expresso.int a = b = c = a, b, c; b = c = 0; ++a; //a = 1, b = 1 a++; //c = 1, a = 2

46

Neste fragmento de cdigo, os valores finais das variveis so a = 2, b = 1 e c = 1. A expresso com o operador de incremento prefixado adiciona 1 ao valor de a antes de atribuir o valor da varivel a varivel b. A expresso com o operador de incremento ps-fixado atribui o valor da varivel a varivel c e, ento, incrementa o valor da varivel a de 1. NOTA: Quando lidam com objetos, as verses prefixadas dos operadores de incremento e decremento so mais eficientes do que as ps-fixadas porque no precisa ser feita uma cpia temporria do objeto para uso na expresso antes que o objeto seja incrementado ou decrementado.

3.14.3.3.14.3.1.

OPERADORES RELACIONAIS E LGICOSOPERADORES RELACIONAIS

Os operadores relacionais so usados para comparar dois valores ou expresses, retornando um valor true ou false. O C++ tem 6 operadores relacionais: a a a a a a

o operador maior que >; o maior ou igual >=; o menor que = b < b a || (a > b b) && (a < c) b b) || (a < c) //Retorna //Retorna //Retorna //Retorna true true true true se se se se a a a a e b forem true for maior do que b e menor do que c ou b forem true for maior do que b ou menor do que c

A avaliao de uma expresso relacional pra assim que o valor lgico da expresso inteira determinado. Por exemplo, a expressoexpr1 && expr2

47

true somente se expr1 e expr2 forem true. Se expr1 for false, o valor final da expresso deve ser false e, portanto, expr2 no avaliada. O operador NOT retorna a negao do valor booleano do seu operando:!a //Se a true, o operador NOT retornar false; e vice-versa.

Estes operadores so freqentemente usados em decises ou em estruturas de lao, que abordaremos no captulo 5.

3.14.4.

OPERADORES BIT-A-BIT

O C++ tem 6 operadores bit-a-bit: o operador AND &; o operador OR |; o operador OR exclusivo ^; o operador complementar ~; o operador de deslocamento para a direita >>; o operador de deslocamento para a esquerda 2, i.e., a = 1 (20).

3.14.5.

O OPERADOR TERNRIO

O operador ternrio ?: (composto de uma interrogao e dois pontos) uma declarao if inline (ver o captulo 5 para mais informaes sobre declaraes if). A expresso para a esquerda do operador ternrio avaliada: se ela for true, o valor ou a expresso entre a interrogao e dos dois pontos retornada; se for false, o valor ou a expresso aps os dois pontos retornada.int a; bool b; b = true; a = b ? 1 : 2; b = false; a = b ? 1 : 2;

//b true. Ento a recebe 1. //b false. Ento a recebe 2.

3.14.6.

O OPERADOR sizeof

O operador sizeof retorna o tamanho em bytes do tipo de dados C++, seja tipo embutido ou definido pelo usurio. Por exemplo, sizeof(int) e sizeof(Animal).

3.14.7.

CONVERSO DE TIPOS

O C++ suporta o operador converso (cast) estilo C, onde o tipo para o qual voc quer converter a expresso colocado entre parnteses em frente expresso. Por exemplo, (float)7. Ele tambm suporta 4 novos operadores: static_cast: muda o tipo de dados da varivel. Por exemplo, se em uma expresso precisamos converter um inteiro em um nmero ponto-flutuante para um clculo, o nmero deve ser convertido usando o operador static_cast. const_cast: muda o carter const da varivel. dynamic_cast: usado para converter objetos para baixo ou para cima do nvel de hierarquia herdada. reinterpret_cast: permite que qualquer ponteiro possa ser convertido para um ponteiro de outro tipo.

int a = 10; double b; b = (double)a; b = static_cast(a);

//Velho operador de converso estilo C //Operador static_cast C++

49

3.14.8.

PRECEDNCIA E ASSOCIATIVIDADE DE OPERADORES

H dois modos para avaliar a expresso 2 + 3 * 4: (2 + 3) * 4 = 20 e 2 + (3 * 4) = 14. As regras de precedncia de operadores permitem avaliao sem ambigidade das expresses. Operadores mais altos na hierarquia tm precedncia sobre operadores mais baixos. Como o operador * tem hierarquia mais alta do que o operador +, a segunda interpretao da expresso acima, 2 + (3 * 4) = 14, seria avaliada. Em situaes onde os dois operadores tm o mesmo nvel na hierarquia, a onda de avaliao procede da esquerda para a direita. Assim, 2 * 3 / 2 * 3 = ((2 * 3) / 2) * 3 = (6 / 2) * 3 = 3 * 3 = 9. Podemos usar parnteses para agrupar operadores e anular a hierarquia de precedncia. Por exemplo, (2 * 3) / (2 * 3) = 1. Idealmente, voc deveria usar parnteses mesmo quando eles no so estritamente requeridos simplesmente para deixar claras as suas intenes. A Tabela 3.2 mostra a hierarquia de precedncia da maior para a menor. Os operadores na mesma linha da tabela compartilham o mesmo nvel de precedncia. Tabela 3.2: Hierarquia de precedncia dos operadores C++ (da maior para a menor).OPERADOR :: . -> [] () ++ -static_cast const_cast dynamic_cast reinterpret_cast sizeof() ++ -^ ! + & * new delete delete[] .* ->* * / % + >> = == != NOME Resoluo de escopo Seleo de membro, subscrio, chamadas de funo, incremento ps-fixado, decremento ps-fixado, operadores de converso

sizeof(), incremento prefixado, decremento prefixado, complementar, negao, menos unrio, mais unrio, endereo de, desreferncia, new, delete, delete[] Ponteiro para operador de membro Multiplicao, Diviso, Mdulo Adio, Subtrao Deslocamento para a direita, deslocamento para a esquerda Operadores relacionais (desigualdades)

Igualdade, Desigualdade

50

& ^ | && || ?: = += -= *= /= %= = = &= |= ^= ,

AND bit-a-bit OR exclusivo OR bit-a-bit AND lgico OR lgico Operador ternrio Operadores de atribuio

Vrgula

3.15.

RPIDAS REFERNCIAS SOBRE O CAPTULO 3

A Tabela 1.3 mostra um resumo deste captulo. Tabela 3. 3: Resumo do captulo 3.PARA Declarar uma varivel FAA ISTO Tipo + espaos + nome da varivel + pontoe-vrgula. Ex.: int number1; long longNumber1; Use o operador de atribuio = Use uma matriz. Transforme a varivel em constante. Ex.: const int x = 10; Declare uma constante enumerada e declare a varivel para ser deste tipo. Use o Add Member Variable Class Wizard. Use a classe .NET String. Use o operador sizeof(). Use o operador static_cast Use parnteses para agrupar operadores.

Atribui valores para uma varivel Agrupar dados homogneos Proteger dados de mudanas Restringir os valores que uma varivel pode aceitar a um pequeno conjunto Adicionar variveis-membros a uma classe Acessar uma classe String Saber o tamanho de um objeto ou de um tipo em bytes Converter um tipo de dados para outro Anular precedncia padro de operador, ou tornar o cdigo mais legvel

51

4.

CAPTULO 4: USANDO FUNES

Neste captulo, voc aprender como: Declarar prottipos de funo; Definir corpos de funo; Chamar funes; Lidar com escopo de varivel local de global; Definir e usar funes sobrecarregadas.

Supomos que at agora voc deve estar bastante confortvel com a sintaxe bsica de C++. Voc viu como declarar variveis, escrever declaraes, usar operadores e realizar sada simples no console. Porm, como seus programas vo comear a crescer, voc precisa organizar seu cdigo para enfrentar a complexidade crescente. Neste captulo, voc aprender como dividir um programa Microsoft Visual C++ em funes. Primeiramente, voc ver como declarar prottipos de funo para introduzir as funes no compilador. A seguir, ver como definir os corpos de funo para realizar o processamento requerido. Por exemplo, voc pode escrever uma funo para calcular o crescimento esperado em um investimento ou para obter a senha de usurio de uma tela de Logon. Finalmente, voc ver como chamar uma funo em qualquer lugar do seu programa. POR QUE USAR FUNES? H muitas boas razes para dividir um programa em funes. Eis algumas: Cada funo usualmente bastante curta e discreta. mais fcil escrever um programa como uma srie de funes do que um nico cdigo, porque voc pode se concentrar em uma funo de cada vez. Tambm mais fcil ler e depurar um programa que contenha algumas pequenas funes do que um que contenha um nico corpo, porque voc no precisa relembrar o que o programa inteiro faz. As funes so reutilizveis. Uma vez escrita uma funo, voc pode cham-la sempre que precisar dela no seu programa, o que reduz o esforo de codificao e, conseqentemente, melhora a produtividade do desenvolvedor.

4.1.

DECL