/* Este programa realiza um somatório e exibe o resultado na tela do computador */

Texto

(1)

(2)

(3)

(4)

(5)

(6)

(7). . . . .

(8) .

(9)

(10)

(11)

(12)

(13)

(14)

(15)

(16)

(17)

(18)

(19)

(20) !

(21)

(22) "

(23)

(24) . # $

(25) %

(26)

(27) #

(28)

(29)

(30)

(31) #

(32) % &

(33)

(34)

(35) %

(36)

(37) %

(38) $ $

(39) ' (

(40) &

(41)

(42)

(43) % ) %

(44) *

(45) ! ' ( &

(46) %

(47)

(48) +'"' ,-. "

(49) ! / 0 % 1

(50) '

(51)

(52)

(53) ! 2

(54)

(55)

(56) 3 2 24 ' %

(57)

(58) 5

(59) ! %

(60) ! %

(61)

(62)

(63) $

(64) #

(65)

(66) %% $

(67) 1 %

(68) 6

(69)

(70) 789: 798: 1 $ . /* Este programa não faz nada */ main() { }. 8 ;; %

(71) 6

(72)

(73)

(74) 88

(75) % %

(76) 1 $ . // Este programa não faz nada main() { }. ' 2 $

(77) + <1 ,=. /* Este programa realiza um somatório e exibe o resultado na tela do computador */ # include <stdio.h> # include <conio.h>. // Diretiva de compilação // Diretiva de compilação. void Total (int); void Exibe(void);. // Protótipo da função “Total” // Protótipo da função “Exibe”. int soma;. // Variável global.

(78)

(79)

(80)

(81)

(82)

(83)

(84). . void Total (int x) // Função “Total” tem um parâmetro { soma = x + soma; } void Exibe() { int cont;. // Função “Exibe” não tem parâmetros // Declaração de variável local. for (cont=0; cont<10; cont++) // Laço de 1 até 10 printf(“.”); // Exibe um ponto na tela printf(“O somatorio corrente eh: %d\n”, soma); // Exibe uma mensagem na tela } void main() { int cont;. // Função principal // Declaração de variável local. clrscr(); soma = 0; for (cont=0; cont<10; cont++) { Total(cont); Exibe(); } getch();. // Limpa a tela // Inicializa a variável com 0 // Laço de 1 até 10 // Chama a função “Total” // Chama a função “Exibe” // Espera que o usuário pressione uma tecla. }. .

(85)

(86) . # ! 6

(87) #

(88)

(89)

(90)

(91)

(92)

(93)

(94) 7>: 3

(95) 4 '

(96)

(97)

(98) ?

(99) " 2

(100)

(101) $ @ %

(102) 3

(103) ?

(104)

(105) 4 2 ?

(106) ?

(107) 3 $ A1 " A4 "

(108) < 'BCD %

(109) %%

(110) $ 3 !

(111) %4 =

(112)

(113)

(114)

(115) EF

(116)

(117)

(118) 1

(119) ?

(120)

(121) +1DB ,, C G ,=. . #$

(122) . .

(123) H IE >F J"

(124) . D

(125) F

(126) K F J "

(127) .

(128)

(129)

(130)

(131)

(132)

(133)

(134). . H 2 % $

(135) %

(136)

(137) C

(138) 7 : % . 3

(139)

(140) !

(141) 4 <

(142) 6

(143)

(144) .

(145) . . . . . . .

(146)

(147)

(148) .

(149) . H % % & G

(150)

(151)

(152)

(153)

(154)

(155) 3

(156)

(157) 4 < < $

(158)

(159)

(160)

(161)

(162)

(163)

(164)

(165) I & 6 % 6 < 'BCD $

(166) #$

(167)

(168)

(169)

(170) 2

(171)

(172)

(173) 2

(174) L

(175) ! '

(176) H

(177)

(178)

(179)

(180) < 'BCD % <

(181)

(182) ?

(183) <

(184)

(185) ' $ 'BCD +C G ,=. . .

(186)

(187) .

(188)

(189) .

(190)

(191)

(192)

(193) .

(194)

(195)

(196)

(197)

(198) . . .

(199) . .

(200)

(201)

(202)

(203)

(204)

(205)

(206). . .

(207)

(208) !

(209)

(210) "

(211) . %

(212) <

(213) ?

(214) 6 M

(215) %

(216) &

(217)

(218)

(219) &

(220) H

(221) '

(222) . tipo lista_de_variáveis;. '%

(223)

(224) '

(225) *

(226) ! 3

(227) 4 N ! 3N 4 ! 3 4 +C G ,=. #$

(228) ! . # include <stdio.h> void main() { int a, b; int SomaGeral; a = 3; b = a * 2; SomaGeral = a + b; : }. // Declaração das variáveis “a” e “b” // Declaração e inicialização da variável “SomaGeral” // Atribuição do valor 3 à variável “a” // Atribuição do dobro do valor da variável “a” para a variável “b” // “SomaGeral” recebe o resultado da soma de “a” e “b”.

(229) % $

(230) %%

(231)

(232)

(233) #

(234)

(235)

(236)

(237)

(238) 3 $ OP4

(239)

(240)

(241) ?

(242)

(243) 3 $ FQ4 %

(244)

(245) ? 3 $ FF,R4 1

(246)

(247) $

(248) ( %

(249)

(250)

(251) 2 6

(252) +1DB ,, C G ,=. #$ . #define LARGURA_MAXIMA #define NRO_DE_DIAS_DA_SEMANA #define NRO_DE_HORAS_DO_DIA #define FALSO #define VERDADEIRO #define UNIVERSIDADE #define TERMINO #define VALOR_DE_PI. 50 7 24 0 1 "Cambridge University" '/' 3.1415 // Obs: não se coloca ponto-e-vírgula após o valor. void main () { int TotalDeHoras; TotalDeHoras = 10 * NRO_DE_DIAS_DA_SEMANA * NRO_DE_HORAS_DO_DIA; printf(“Local: %s”, UNIVERSIDADE); ...... }.

(253)

(254)

(255)

(256)

(257)

(258)

(259). #. .

(260) !

(261) . %

(262) #

(263)

(264) 7

(265) : % 2

(266) 2 S

(267)

(268)

(269) %

(270) %

(271) 6

(272)

(273)

(274)

(275) %

(276)

(277) /

(278) 0 #$

(279) . . : void func1(void) { int x; x = 10; }. void func2(void) { int x; x = -199; } :. // Variável local. // Variável local (não tem relação com a anterior). '

(280) 2

(281) %%

(282) 1

(283)

(284) %%

(285)

(286) 1 $ . void f(void) { int t; scanf(“%d”, &t);. // Variável local // Valor digitado é atribuído a t. if (t == 1) { // início do bloco if char s[80]; // s é criada apenas na entrada deste bloco printf(“Digite o nome: “); gets(s); .... } // fim do bloco if, s é “destruída” }. '

(287)

(288)

(289)

(290)

(291)

(292) %

(293)

(294) $ %

(295) %

(296) 6

(297) M % 2

(298)

(299)

(300)

(301) % %%

(302) 1 $

(303)

(304)

(305)

(306)

(307) . /* Esta função está errada */ void f(void) { int i; i = 10;. int j; // Esta linha irá provocar um erro j = 20; }. 1 7:

(308)

(309)

(310)

(311) 7:

(312) 1 $ $ !

(313)

(314)

(315) +C G ,=..

(316)

(317)

(318)

(319)

(320)

(321)

(322). . /* Define j dentro de seu próprio bloco de código */ void f(void) { int i; i = 10; { int j; j = 20; } } /* Define j no início do bloco da função */ void f(void) { int i; int j; i = 10; j = 20; }. %

(323)

(324) % %%

(325) % $

(326) 1

(327)

(328) 2 %%

(329) . B 7

(330) :

(331) ! #

(332)

(333)

(334)

(335) %% % B

(336)

(337) #include <stdio.h>. int cont;. // Variável global. void func1(void); void func2(void); void main (void) { cont = 100; func1(); } void func1(void) { int temp; temp = cont; func2(); printf(“cont eh %d”, cont); }. // Exibirá 100. void func2(void) { int cont; for (cont=1; cont<10; cont++) putchar(‘.’); }. < &

(338) 2 $

(339) S ? % ! 2 $

(340) #

(341) % $

(342) $ !

(343)

(344)

(345)

(346) 6

(347) +C G ,=..

(348)

(349)

(350)

(351)

(352)

(353)

(354). $. . "

(355)

(356) !

(357) . '

(358)

(359)

(360)

(361) ! &

(362) % %

(363) % # $

(364)

(365) & T *

(366) $ .

(367) . & % % 6

(368) 6

(369)

(370) 6

(371) 6 &2

(372)

(373)

(374) %

(375) & %

(376) %

(377) %

(378) !

(379)

(380) // Arquivo 1. // Arquivo 2. int x, y; char ch;. extern int x, y; extern char ch;. main (void) { : }. func22(void) { x = y/10; }. func1() { x = 123; }. func23() { y = 10; }. S % '

(381)

(382)

(383) % *

(384) #

(385)

(386)

(387) ? !

(388) !

(389) % . <

(390)

(391)

(392)

(393) T

(394)

(395)

(396)

(397) & %

(398)

(399) & ' %

(400)

(401)

(402)

(403)

(404) %

(405) J

(406)

(407)

(408) %

(409) $ % %

(410)

(411) ? % & ? B

(412)

(413)

(414)

(415)

(416) ! '

(417) % ?

(418)

(419)

(420) $ // Exemplo de declaração/uso de variáveis static locais #include <stdio.h> #include <conio.h> void func1(void); int series(void); void main (void) { clrscr(); printf("Numero de serie: %d \n", series()); func1(); printf("Numero de serie: %d \n", series()); getch(); }.

(421)

(422)

(423)

(424)

(425)

(426)

(427). . void func1(void) { printf("Teste... \n"); } int series(void) { static int series_num = 100; // valor de inicialização da variável (atribuído apenas uma vez) series_num = series_num + 23; return(series_num); }. 1

(428)

(429)

(430)

(431)

(432)

(433) %

(434)

(435) % %

(436) D

(437) % 6 ! %

(438)

(439) *2

(440) ?

(441) 6

(442) #

(443) !

(444)

(445) & 2

(446) % % %

(447) ! %

(448)

(449)

(450) %

(451) 1

(452) $ %

(453) &

(454) 7 !": B

(455) %

(456) // Exemplo de declaração/uso de variáveis static globais // Todo este código deve ficar em um único arquivo, preferencialmente isolado #include <stdio.h> #include <conio.h> static int series_num; void series_start(int seed); int series(void); void series_start (int seed) { series_num = seed; }. // Inicializa a variável static series_num. int series(void) // Cria novo número de série { series_num = series_num + 23; return(series_num); }. "

(457)

(458)

(459)

(460)

(461) . 'BCD % 7

(462) : B

(463)

(464)

(465) & 1 & D &

(466) % !

(467)

(468)

(469) . 1

(470)

(471) L

(472) <6

(473) & &

(474)

(475) %

(476)

(477)

(478)

(479). <

(480)

(481)

(482)

(483) N ' < $

(484)

(485) $

(486) .

(487)

(488)

(489)

(490)

(491)

(492)

(493). .

(494)

(495) 2

(496) #

(497)

(498) U // Exemplo declaração/uso de variáveis register. #include <stdio.h> #include <conio.h> int_pwr(register int, register int); void main (void) { int X; clrscr(); X = int_pwr(3, 2); printf("X = %d", X); getch(); } int_pwr(register int m, register int e) // "m" e "e" declaradas como register porque são usadas num laço { register int temp; temp = 1; for (; e; e--) temp = temp * m; return temp; }. < ? %%

(499)

(500)

(501)

(502) B 2

(503) %

(504)

(505)

(506) %

(507) 3

(508)

(509) 4 B

(510)

(511)

(512) 1 <

(513)

(514)

(515)

(516) 1 $ const int a=10;, cria uma variável inteira com um valor inicial 10, que o programa não pode modificar [SCH 96].. %. &

(517)

(518) . < % 1 $ 3;4 %

(519) 324 % # % '

(520) 3K4 % ?

(521) +CV' ,E..

(522) ?

(523) $ # %

(524) 3

(525) 4

(526)

(527)

(528) '

(529)

(530) '

(531) $ < W %% $ .

(532)

(533)

(534)

(535)

(536)

(537)

(538). !. %

(539)

(540)

(541)

(542)

(543)

(544) . 2 L %

(545) #

(546)

(547) 3 $ 4

(548) % 3 4 #$ . int x; char ch; float f; ch = x; // ch recebe os 8 bits menos significativos de x; se x está entre 256 e 0, então x=ch x = f; // x recebe a parte inteira de f f = ch; // f converte o valor inteiro(8 bits) armazenado em ch no mesmo valor em formato de ponto flutuante f = x; // f converte o valor inteiro(16 bits) armazenado em x no mesmo valor em formato de ponto flutuante. T

(549)

(550)

(551)

(552)

(553) % %

(554) '

(555)

(556)

(557) $ % . % 6 ! ? ?

(558)

(559) #$ . x = y = z = 0;. H 2

(560) % $ '

(561)

(562) . <tipo> <expressão>. XY %% 1 $ % $ 7#$: 2 % 7: 2 (float) x/2;. %

(563)

(564)

(565)

(566) *

(567) % %% # 6 ? %

(568) 1 $ % 6

(569)

(570) ! $

(571)

(572) . #include <stdio.h> void main(void) // imprime i e i/2 com frações { int i; for (i=1; i<=100; ++i) printf(“%d / 2 eh: %f \n”, i, (float) i/2); }. < . %

(573) % . . Operador -- , ++ * , / % - , +. Ação Decremento e Incremento Menos unário Multiplicação e Divisão Módulo (resto de divisão inteira) Subtração e Adição. Precedência Maior. Menor. <

(574)

(575) % %% " 2 % % 78:

(576)

(577)

(578) %%

(579) 7Z: #$ .

(580)

(581)

(582)

(583)

(584)

(585)

(586). . : int x, y; x = 5; y = 2; printf(“%d”, x/y); // mostrará 2 printf(“%d”, x%y); // mostrará 1, o resto da divisão inteira x = 1; y = 2; printf(“%d %d”, x/y, x%y); // mostrará 0 1 :. " ?

(587)

(588) 3;;4

(589) 3224 < 1 $ 7 &: % 7&&: 7&&:

(590) 7 : % 722: 7: '

(591)

(592) &

(593) $ $ % $ ! T

(594)

(595)

(596) $

(597)

(598)

(599) C

(600) 2

(601) 2 1 $ . x = 10; y = ++x; // y recebe 11, x recebe 11 x = 10; y = x++; // y recebe 10, x recebe 11 : int a, b, c, i = 3; // a: ? b: ? c: ? i: 3 a = i++; // a: 3 b: ? c: ? i: 4 b = ++i; // a: 3 b: 5 c: ? i: 5 c = --i; // a: 3 b: 5 c: 4 i: 4 :. B

(602) 2 L ! %

(603) B

(604) 2 L

(605) !

(606)

(607) & %

(608)

(609) %[ 6

(610)

(611) 6 . . . '

(612)

(613)

(614)

(615) # %% & \ & ' $ ! %

(616)

(617) & <

(618)

(619) Operador ! >, >=, <, <= ==, != && ||. Ação Negação (ou NOT) Maior que, Maior ou igual que, Menor que, Menor ou igual que Igual, Diferente Condição “E” (ou AND) Condição “OU” (ou OR). Precedência Maior. Menor. '

(620) . . . . . 0 0 1 1. 0 1 1 0. 0 0 1 0. 0 1 1 1. 1 1 0 0. % 6

(621) ! $

(622) $ . 10>5 && !(10<9) || 3 <=4. B

(623) .

(624)

(625)

(626)

(627)

(628)

(629)

(630). . '

(631)

(632)

(633) 6 & % 6 % ! % < 2

(634) %

(635)

(636) H !

(637) $ < . . Operador & | ^ ~ >> <<. Ação AND OR OR exclusivo (XOR) Complemento de um (NOT) Deslocamento à esquerda Deslocamento à direita. ' ! 'B" <J B<H %

(638) $

(639) < <J $

(640) 3]4 . . . Q Q Q F Q F F F Q Q F F.

(641) ^<J $

(642)

(643) <

(644)

(645) ! %[ _

(646) %

(647) _ % !

(648)

(649)

(650) <

(651)

(652) M

(653)

(654) #$ . : // Uma função simples de criptografia char encode(char ch) { return(~ch); // complementa } // para decriptografar, basta fazer um novo complemento : : // Programa que exemplifica o deslocamento de bits #include <stdio.h> void main (void) { unsigned int i; int j; i=1; // Deslocamentos à esquerda for (j=0; j<4; j++) { i = i << 1; // desloca i de 1 à esquerda, que é o mesmo que multiplicar por 2 printf(“Deslocamento à esquerda %d: %d \n”, j, i); }.

(655)

(656)

(657)

(658)

(659)

(660)

(661). . // Deslocamentos à direita for (j=0; j<4; j++) { i = i >> 1; // desloca i de 1 à direita, que é o mesmo que dividir por 2 printf(“Deslocamento à direita %d: %d \n”, j, i); } }. #$ % ` 9

(662)

(663)

(664)

(665) # * * !

(666) #

(667)

(668) & % ! % N

(669)

(670) N

(671) . < ` # % 1 $ m = &count;. ! 7

(672) : 7: #

(673)

(674) 7

(675) : 1 2 `

(676)

(677) 7 : "

(678) 7

(679)

(680) : < 9 %

(681) ` < 9 %

(682) & % 1 $ 7:

(683) 7

(684) : q = *m;.

(685)

(686) 7

(687) : 7': 1 9

(688)

(689) 7 : B

(690)

(691) 7'

(692) : B $ $ 9 `

(693)

(694) FQ

(695) 7 : FQ . #include <stdio.h> void main (void) { int target, source; int *m; source = 10; m = &source; target = *m; printf(“%d”, target); }. '.

(696)

(697) (

(698) &

(699)

(700) . #

(701) *

(702) % < * ' $

(703) *

(704) +C G ,=..

(705)

(706)

(707)

(708)

(709)

(710)

(711). 1

(712) *

(713) U. U . . < 34 +. 2Y K a ;; 22 2 34 9 ` & 9 8 Z ; 2 XX YY X XW Y YW WW KW ` ] K `` KK b W ;W 2W 9W 8W

(714) .

(715)