Desenvolvimento de Software em C e C++

Prévia do material em texto

Aula 03 - Somente em
PDF
POLITEC-PE (Perito Criminal - Área 5 -
Ciências da Computação ou Sistemas de
Informação) Desenvolvimento de
Software - 2024 (Pós-Edital)
Autor:
Paolla Ramos
13 de Maio de 2024
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
Paolla Ramos
Aula 03 - Somente em PDF
Índice
..............................................................................................................................................................................................1) Desenvolvimento - Linguagem C e C++ - Teoria 3
..............................................................................................................................................................................................2) Desenvolvimento - Linguagem C e C++ - Resumo 58
..............................................................................................................................................................................................3) Desenvolvimento - Linguagem C e C++ - Questões Comentadas 69
..............................................................................................................................................................................................4) Desenvolvimento - Linguagem C e C++ - Lista de Questões 123
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
2
180
 
 
 
Sumário 
Apresentação da Aula ........................................................................................................................................ 3 
Linguagem de Programação C .......................................................................................................................... 4 
Conceitos Básicos .......................................................................................................................................... 4 
Sintaxe C ........................................................................................................................................................ 6 
C é uma linguagem estruturada ................................................................................................................ 7 
Compiladores Versus Interpretadores ....................................................................................................... 8 
A Forma de um Programa em C ................................................................................................................ 8 
Compilar um programa em C .................................................................................................................... 9 
Os Cinco Tipos Básicos de Dados ............................................................................................................ 14 
Modificando os Tipos Básicos .................................................................................................................. 15 
Nomes de Identificadores ........................................................................................................................ 16 
Variáveis ................................................................................................................................................... 16 
Onde as variáveis são declaradas ............................................................................................................ 17 
Variáveis Globais ...................................................................................................................................... 18 
Parâmetros Formais ................................................................................................................................. 19 
Modificadores de Tipo de Acesso ............................................................................................................ 20 
volatile ...................................................................................................................................................... 21 
Variáveis static ......................................................................................................................................... 21 
Variáveis Globais static ............................................................................................................................ 22 
Variáveis register...................................................................................................................................... 22 
Variáveis ................................................................................................................................................... 23 
Inicialização de Variáveis ......................................................................................................................... 24 
Identificadores ......................................................................................................................................... 25 
Constantes ............................................................................................................................................... 26 
Entrada do usuário ................................................................................................................................... 26 
Tipos de dados ......................................................................................................................................... 27 
Operadores .............................................................................................................................................. 29 
Strings ...................................................................................................................................................... 34 
Matemática C++ ....................................................................................................................................... 38 
C++ Booleans............................................................................................................................................ 41 
Estruturas de Controle de Fluxo .................................................................................................................. 43 
If...Else ...................................................................................................................................................... 43 
Switch ....................................................................................................................................................... 46 
While......................................................................................................................................................... 47 
Do/While ................................................................................................................................................... 48 
For ............................................................................................................................................................. 50 
Break and Continue.................................................................................................................................. 51 
Array ......................................................................................................................................................... 52 
Resumo ................................................................................................................. Erro! Indicador não definido. 
Matemática C++ ........................................................................................... Erro! Indicador não definido. 
Estrutura de Controle de Fluxo .................................................................... Erro! Indicador não definido. 
Questões Comentadas ......................................................................................... Erro! Indicadornão definido. 
Diversas Bancas ............................................................................................... Erro! Indicador não definido. 
Gabarito................................................................................................................ Erro! Indicador não definido. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
3
180
 
 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
4
180
==30e709==
 
 
 
APRESENTAÇÃO DA AULA 
 
Olá, galera! Vamos iniciar os estudos sobre as Linguagens de 
Programação C e C++! 
 
Essa imagem é CLÁSSICA! Dennis MacAlistair Ritchie, foi o cientista 
da computação responsável pela criação de uma das linguagens de 
programação mais importantes da atualidade: a linguagem de 
programação C. Dennis também é um dos cocriadores do sistema 
operacional UNIX. A importância desse sistema advém da introdução 
de um padrão de sistema operacional que se tornou amplamente 
popular, que foi também utilizado como base para criação do LINUX. 
 
É uma linguagem de programação de Médio Nível e de propósito 
geral. C é uma Linguagem de Médio Nível. De acordo com Herbert 
Schildt, C é frequentemente chamada de linguagem de médio nível 
para computadores. Isso não significa que C seja menos poderosa, 
difícil de usar ou menos desenvolvida que uma linguagem de alto 
nível como BASIC e Pascal, tampouco implica que C seja similar à 
linguagem assembly e seus problemas correlatos aos usuários. C é tratada como uma linguagem de médio 
nível porque combina elementos de linguagens de alto nível com a funcionalidade da linguagem assembly. 
 
A Linguagem C é uma linguagem estruturada que permite a criação de programas eficientes e de alto 
desempenho. É amplamente utilizada em sistemas operacionais, aplicativos de software de baixo nível, 
dispositivos eletrônicos e jogos. 
 
Nesta aula, além dos conceitos da linguagem, apresento inúmeras palavras-chave e informações relevantes 
com ênfase no que cai na prova, para que vocês possam entender e internalizar o conteúdo de forma simples 
e eficiente. Aproveitem o material, além dos esquemas, resumos e mnemônicos, não deixe de fazer o maior 
número de questões possível. Vamos ao que importa! 
 
Só mais uma coisa: Eu me dediquei escrevendo essa aula, porém, como não sou um robô e sou HUMANA, 
posso ter cometido algum erro... Se encontrar algum erro na aula, por favor, me informe no 
@prof.paollaramos 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
5
180
 
 
 
LINGUAGEM DE PROGRAMAÇÃO C 
Conceitos Básicos 
 
Antes de iniciar a aula, é importante mencionar que vários exemplos dessa aula foram retirados ou inspirados 
em exemplos do W3Tutorials (https://www.w3schools.com/c e https://www.w3schools.com/cpp). Não 
fizemos isso porque somos preguiçosos, mas por dois motivos: (1) os exemplos são excelentes; (2) essa é 
uma das fontes de inspiração das bancas. Além disso, eu sugiro que vocês tenham sempre aberta uma janela 
com um interpretador online para que vocês possam testar o que veremos. Recomendo o 
www.w3schools.com 
 
C é uma linguagem de programação de propósito geral que foi desenvolvida na década de 1970 por Dennis 
Ritchie no Bell Labs. É uma linguagem de baixo nível que permite aos programadores escrever código 
eficiente e de alto desempenho. 
 
Ela se tornou popular por sua eficiência e por ser uma das primeiras linguagens a permitir que os 
programadores escrevessem programas que acessavam diretamente a memória do computador, 
permitindo que programas mais rápidos e eficientes fossem criados. A linguagem C também é conhecida por 
ser portável, o que significa que um programa escrito em C pode ser compilado e executado em diferentes 
plataformas, como sistemas operacionais diferentes ou diferentes processadores. 
 
O C++ é uma extensão da linguagem C, criada por Bjarne Stroustrup na década de 1980. Ele adiciona recursos 
adicionais, como a programação orientada a objetos, que permitem aos programadores criar programas 
mais complexos e modulares. A programação orientada a objetos é uma técnica de programação que 
organiza o código em objetos que têm suas próprias propriedades e métodos, tornando o código mais fácil 
de entender e manter. O C++ também adicionou recursos como sobrecarga de operadores, templates e 
exceções, tornando-o uma linguagem mais poderosa e flexível do que o C. 
 
Apesar de ser uma extensão do C, o C++ não é totalmente compatível com a linguagem C. Por exemplo, o 
C++ introduziu uma nova palavra-chave para a alocação de memória (new), enquanto o C usava a função 
malloc(). Além disso, o C++ adicionou novos recursos, como as classes e a herança, que não existiam na 
linguagem C. 
 
A evolução do C++ continuou, com a adição de novos recursos e aprimoramento dos existentes. A versão 
mais recente é o C++20, lançado em 2020, que adicionou recursos como módulos, conceitos e melhorias na 
programação concorrente. No entanto, o C ainda é amplamente utilizado e é considerado uma linguagem 
importante, especialmente na programação de sistemas, enquanto o C++ é frequentemente usado na 
programação de aplicativos, jogos e outras aplicações complexas. 
 
• Compilação: O código C é escrito em um arquivo de texto com extensão .c. Esse código precisa ser 
compilado antes de poder ser executado. A compilação transforma o código em linguagem de 
máquina que o computador pode entender. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
6
180
 
 
 
• Variáveis: As variáveis em C são usadas para armazenar valores, como números ou strings. Cada 
variável tem um tipo, como int para números inteiros ou char para caracteres. As variáveis precisam 
ser declaradas antes de serem usadas. 
 
• Tipos de dados: C tem vários tipos de dados, incluindo int, char, float e double. Cada tipo de dado 
tem um tamanho diferente na memória e é usado para armazenar diferentes tipos de informações. 
 
• Operadores: C tem uma série de operadores, como + para adição, - para subtração, * para 
multiplicação e / para divisão. Os operadores são usados para realizar cálculos em variáveis. 
 
• Estruturas de controle: C tem três principais estruturas de controle: if/else, for e while. Essas 
estruturas são usadas para controlar o fluxo do programa, permitindo que os programadores tomem 
decisões ou repitam ações. 
 
• Funções: As funções em C são blocos de código que realizam uma tarefa específica. As funções são 
usadas para dividir o código em partes menores e mais gerenciáveis, tornando o código mais fácil de 
ler e manter. 
 
• Bibliotecas: As bibliotecas em C são coleções de funções que podem ser usadas para realizar tarefas 
específicas. C tem uma grande variedade de bibliotecas disponíveis, como stdio.h para entrada e 
saída, e math.h para funções matemáticas. 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
7
180
 
 
 
Sintaxe C 
 
A sintaxe da Linguagem C é baseada em um conjunto de regras que definem como escrevere estruturar o 
código para que ele possa ser compreendido e executado pelo compilador. 
 
Um programa em C é composto por um conjunto de Funções. A função pela qual o programa começa a ser 
executado chama-se main. Após cada cada comando em C deve-se colocar um ; (ponto-e-vírgula). Um 
programa em C deve ser Identado para que possa ser lido com mais facilidade. 
 
 
 
A sintaxe da Linguagem C é composta por um conjunto de regras gramaticais que determinam como as 
instruções e expressões devem ser escritas e organizadas no código fonte. Algumas das principais 
características da sintaxe da Linguagem C incluem: 
 
• C é uma linguagem de programação baseada em texto, o que significa que os programas são escritos 
em um arquivo de texto usando um editor de texto. 
 
• C é uma linguagem de programação case sensitive, o que significa que letras maiúsculas e minúsculas 
são tratadas de maneira diferente. 
 
• O ponto e vírgula (;) é usado para indicar o final de uma instrução em C. 
 
• As chaves ({}) são usadas para delimitar blocos de código em C. Um bloco de código pode conter 
zero ou mais instruções. 
 
• A maioria das palavras-chave em C são reservadas, o que significa que não podem ser usadas como 
nomes de variáveis, funções ou outros identificadores no programa. 
 
• C usa operadores aritméticos padrão, como +, -, * e / para realizar cálculos matemáticos. 
 
• Os comentários em C são iniciados com // para comentários em uma linha ou /* e terminados com 
*/ para comentários de várias linhas. 
 
• C usa declarações de variáveis para declarar as variáveis e seu tipo de dados. 
 
Além disso, na sintaxe da Linguagem C é importante entender os conceitos de variáveis e tipos de dados. As 
variáveis são utilizadas para armazenar valores na memória do computador e podem ter diversos tipos, como 
inteiros (int), números de ponto flutuante (float), caracteres (char), entre outros. 
conjunto de Funções Início: main Após cada cada 
comando ;
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
8
180
 
 
 
 
Também é possível declarar constantes na Linguagem C, utilizando a palavra-chave const, e trabalhar com 
operadores, que são símbolos utilizados para realizar operações matemáticas e lógicas, como soma (+), 
subtração (-), multiplicação (*), divisão (/), entre outros. 
 
Por fim, a Linguagem C possui diversas bibliotecas, que são conjuntos de funções já definidas e prontas para 
serem utilizadas em um programa. Essas bibliotecas são incluídas no código utilizando a diretiva #include, 
seguida do nome da biblioteca desejada. Vamos ver tudo isso nessa aula! 
 
C é uma linguagem estruturada 
 
Uma linguagem estruturada permite muitas possibilidades na programação. Ela suporta, diretamente, 
diversas construções de laços (loops), como while, do-while e for. Se você não sabe o que é um loop, leia a 
explicação abaixo, caso já saiba, siga em frente! 
 
Laços, ou loops, são estruturas de controle de fluxo em programação que permitem que um bloco de código 
seja executado repetidamente enquanto uma determinada condição for verdadeira. As três estruturas de 
loops mais comuns em C são: while, do-while e for. 
 
O laço while é a forma mais simples de loop. Ele consiste em uma expressão booleana que é testada a cada 
iteração do loop. Enquanto a condição for verdadeira, o bloco de código dentro do loop será executado. 
Exemplo: 
 
int i = 0; 
while (i < 10) { 
 printf("%d\n", i); 
 i++; 
} 
 
O laço do-while é semelhante ao while, mas a condição é testada após a primeira execução do loop, 
garantindo que o bloco de código dentro do loop seja executado pelo menos uma vez. Exemplo: 
 
int i = 0; 
do { 
 printf("%d\n", i); 
 i++; 
} while (i < 10); 
 
O laço for é uma forma mais complexa de loop que consiste em três partes: a inicialização, a condição e a 
atualização. A inicialização é executada uma única vez no início do loop, a condição é testada a cada iteração 
e o bloco de código dentro do loop é executado enquanto a condição for verdadeira. A atualização é 
executada no final de cada iteração do loop. Exemplo: 
 
for (int i = 0; i < 10; i++) { 
 printf("%d\n", i); 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
9
180
 
 
 
} 
 
Em uma linguagem estruturada, o uso de goto é proibido ou desencorajado e também a forma comum de 
controle do programa, (que ocorre em BASIC e FORTRAN, por exemplo). Uma linguagem estruturada permite 
que você insira sentenças em qualquer lugar de uma linha e não exige um conceito rigoroso de campo (como 
em FORTRAN). 
 
O principal componente estrutural de C é a função a sub-rotina isolada de C. Em C, funções são os blocos de 
construção em que toda a atividade do programa ocorre. Elas admitem que você defina e codifique 
separadamente as diferentes tarefas de um programa, permitindo, então, que seu programa seja modular. 
Após uma função ter sido criada, você pode esperar que ela trabalhe 
adequadamente em várias situações, sem criar efeitos inesperados em outras partes do programa. O fato 
de você poder criar funções isoladas é extremamente importante em projetos maiores nos quais um código 
de um programador não deve afetar acidentalmente o de outro. 
 
Compiladores Versus Interpretadores 
 
Os termos compiladores e interpretadores referem-se à maneira como um programa é executado. Existem 
dois métodos gerais pelos quais um programa pode ser executado. Em teoria, qualquer linguagem de 
programação pode ser compilada ou interpretada, mas algumas linguagens geralmente são executadas de 
uma maneira ou de outra. Por exemplo, BASIC é normalmente interpretada e C, compilada. A maneira pela 
qual um programa é executado não é definida pela linguagem em que ele é escrito. Interpretadores e 
compiladores são simplesmente programas sofisticados que operam sobre o código-fonte do seu programa. 
Como a diferença entre um compilador e um interpretador pode não ser clara para todos os leitores, a breve 
descrição seguinte esclarecerá o assunto. 
 
Um interpretador lê o código-fonte do seu programa uma linha por vez, executando a instrução específica 
contida nessa linha. Um compilador lê o programa inteiro e converte-o em um código-objeto, que é uma 
tradução do código-fonte do programa em uma forma que o computador possa executar diretamente. 
 
O código-objeto é também conhecido como código binário ou código de máquina.Uma vez que o programa 
tenha sido compilado, uma linha do código-fonte, mesmo alterada, não é mais importante na execução do 
seu programa. 
 
A Forma de um Programa em C 
 
Apresento agora uma lista das 32 palavras-chave (ou palavras reservadas) que, combinadas com a sintaxe 
formal de C, formam a linguagem de programação C. Destas, 27 foram definidas pela versão original de C. 
As cinco restantes foram adicionadas pelo comitê ANSI: enum, const, signed, void e volatile. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
10
180
 
 
 
Uma lista das palavras-chave de C ANSI1 
auto double int struct 
break else long switch 
case enum register typedef 
char extern return union 
const float short unsigned 
continue for signed void 
default goto sizeof volatile 
do if static while 
 
Todo programa em C consiste em uma ou mais funções. A única função que necessariamente precisa estar 
presente é a denominada main(), que a primeira função a ser chamada quando a execução do programacomeça. Em um código de C bem escrito, main() contém, em essência, um esboço do que o programa faz. O 
esboço é composto de chamadas de funções. Embora main() não seja tecnicamente parte da linguagem C, 
trate-a como se fosse. Não tente usar main() como nome de uma variável porque provavelmente confundirá 
o compilador. 
 
Compilar um programa em C 
 
Compilar um programa em C/C++ significa transformar o código fonte escrito em linguagem de programação 
em um arquivo executável que possa ser entendido e executado pelo computador. Para compilar um 
programa, é necessário utilizar um compilador específico para a linguagem de programação escolhida. O 
compilador irá ler o código fonte e gerar o código objeto, que posteriormente será vinculado a outras 
bibliotecas e gerar o arquivo executável. O processo de compilação pode ser feito através de linha de 
comando ou utilizando ambientes de desenvolvimento integrado (IDEs). O arquivo executável gerado pode 
então ser executado no computador. Compilar um programa em C consiste nestes três passos: 
 
1. Criar o programa 
2. Compilar o programa 
3. Linkeditar o programa com as funções necessárias da biblioteca 
 
Alguns compiladores fornecem ambientes de programação integrados que incluem um editor. Com outros, 
é necessário usar um editor separado para criar seu programa. Os compiladores só aceitam a entrada de 
arquivos de texto padrão. Por exemplo, seu compilador não aceitará arquivos criados por certos 
processadores de textos porque eles têm códigos de controle e caracteres não-imprimíveis. 
 
 
1 ANSI significa American National Standards Institute (Instituto Nacional Americano de Padrões, em 
português) e é uma organização sem fins lucrativos que desenvolve e publica normas e padrões para 
várias áreas, incluindo tecnologia 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
11
180
 
 
 
O método exato que você utiliza para compilar um programa depende do compilador que está em uso. Além 
disso, a linkedição varia muito entre os compiladores e os ambientes. Existem muitos ambientes de 
desenvolvimento para a linguagem C disponíveis no mercado, alguns dos mais populares incluem: 
 
Visual Studio Code: é um editor de código-fonte leve, mas poderoso, executado em sua área de trabalho e 
disponível para Windows, macOS e Linux. Ele vem com suporte integrado para JavaScript, TypeScript e 
Node.js e possui um rico ecossistema de extensões para outras linguagens e tempos de execução (como C++, 
C#, Java, Python, PHP, Go, .NET). Comece sua jornada com o VS Code com esses vídeos introdutórios. 
 
 
 
Code::Blocks: é um IDE gratuito, de código aberto e multiplataforma . Usando uma arquitetura de plug-in, 
seus recursos e recursos são definidos pelos plug-ins fornecidos. Atualmente, Code::Blocks é orientado para 
C/C++/Fortran. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
12
180
 
 
 
 
 
Eclipse CDT: fornece um Ambiente de Desenvolvimento Integrado C e C++ totalmente funcional baseado na 
plataforma Eclipse. Os recursos incluem: suporte para criação de projeto e construção gerenciada para várias 
cadeias de ferramentas, criação padrão, navegação de origem, várias ferramentas de conhecimento de 
origem, como hierarquia de tipos, gráfico de chamada, navegador de inclusão, navegador de definição de 
macro, editor de código com realce de sintaxe, dobra e hiperlink navegação, refatoração de código-fonte e 
geração de código, ferramentas de depuração visual, incluindo memória, registradores e visualizadores de 
desmontagem. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
13
180
 
 
 
 
 
Dev-C++: é um Ambiente de Desenvolvimento Integrado (IDE) C e C++ completo para plataformas Windows. 
Milhões de desenvolvedores, estudantes e pesquisadores usam o Dev-C++ desde que a primeira versão foi 
lançada em 1998. Ele foi apresentado em dezenas de C++ e livros científicos e continua sendo uma das 
ferramentas de aprendizado favoritas entre universidades e escolas em todo o mundo. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
14
180
 
 
 
 
 
NetBeans IDE é um ambiente de desenvolvimento integrado gratuito e de código aberto para 
desenvolvedores de software nas linguagens Java, JavaScript, HTML5, PHP, C/C++, Groovy, Ruby, entre 
outras. O IDE é executado em muitas plataformas, como Windows, Linux, Solaris e MacOS 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
15
180
 
 
 
 
 
Os Cinco Tipos Básicos de Dados 
 
Há cinco tipos básicos de dados em C: caractere, inteiro, ponto flutuante, ponto flutuante de precisão dupla 
e sem valor (char, int, float, double e void, respectivamente). Como você verá, todos os outros tipos de dados 
em C são baseados em um desses tipos. O tamanho e a faixa desses tipos de dados variam de acordo com o 
tipo de processador e com a implementação do compilador C. Um caractere ocupa geralmente 1 byte e um 
inteiro tem normalmente 2 bytes, mas você não pode fazer esta suposição se quiser que seus programas 
sejam portáveis a uma gama mais ampla de computadores. O padrão ANSI estipula apenas a faixa mínima 
de cada tipo de dado, não o seu tamanho em bytes. 
 
O formato exato de valores em ponto flutuante depende de como eles são implementados. Inteiros 
geralmente correspondem ao tamanho natural de uma palavra do computador host. Valores do tipo char 
são normalmente usados para conter valores definidos pelo conjunto de caracteres ASCII. Valores fora dessa 
faixa podem ser manipulados diferentemente entre as implementações de C. 
 
Tipo 
Tamanho aproximado 
em bits 
Faixa Mínima 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
16
180
 
 
 
char 8 -127 a 127 
unsigned char 8 0 a 255 
signed char 8 -127 a 127 
int 16 -32.767 a 32.767 
unsigned int 16 0 a 65.535 
signed int 16 O mesmo que int 
short int 16 O mesmo que int 
unsigned short int 16 0 a 65.535 
signed short int 16 O mesmo que short int 
long int 32 -2.147.483.647 a 2.147.483.647 
signed long int 32 O mesmo que long int. 
unsigned long int 32 0 a 4.294.967.295 
float 32 Seis dígitos de precisão 
double 64 Dez dígitos de precisão 
long double 80 Dez dígitos de precisão 
 
Modificando os Tipos Básicos 
 
Com exceção do void, os tipos de dados básicos podem ter vários modificadores precedendo-os. Um 
modificador é usado para alterar o significado de um tipo básico para adaptá-lo mais precisamente às 
necessidades de diversas situações. A lista de modificadores é mostrada aqui: 
• signed 
• unsigned 
• long 
• short 
 
Os modificadores signed, short, long e unsigned podem ser aplicados aos tipos básicos caractere e inteiro. 
Contudo, long também pode ser aplicado a double. (Note que o padrão ANSI elimina o long float porque ele 
tem o mesmo significadode um double.) 
A Tabela 2.1 mostra todas as combinações de tipos de dados que atendem ao padrão ANSI juntamente com 
suas faixas mínimas e larguras aproximadas em bits. 
 
O uso de signed com inteiros é permitido, mas redundante porque a declaração padrão de inteiros assume 
um número com sinal. O uso mais importante de signed é modificar char em implementações em que esse 
tipo, por padrão, não tem sinal. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
17
180
 
 
 
Algumas implementações podem permitir que unsigned seja aplicado aos tipos de ponto flutuante (como 
em unsigned double). Porém, isso reduz a portabilidade de seu código e geralmente não é recomendável. 
Qualquer tipo expandido ou adicional não definido pelo padrão proposto ANSI provavelmente não será 
suportado por todas as implementações de C. 
 
A diferença entre inteiros com ou sem sinal é a maneira como o bit mais significativo do inteiro é 
interpretado. Se um inteiro com sinal é especificado, o compilador C gerará um código que assume que o bit 
de mais alta ordem de um inteiro deve ser interpretado como indicador de sinal. Se o indicador de sinal é 0, 
o número é positivo; se é 1, o número é negativo. 
 
Em geral, os números negativos são representados usando-se o complemento de dois, que inverte todos os 
bits em um número (exceto o indicador de sinal), adiciona 1 a esse número e põe o indicador de sinal em 1. 
 
Nomes de Identificadores 
 
Em C, os nomes de variáveis, funções, rótulos e vários outros objetos definidos pelo usuário são chamados 
de identificadores. Esses identificadores podem variar de um a diversos caracteres. O primeiro caractere 
deve ser uma letra ou um sublinhado e os caracteres subseqüentes devem ser letras, números ou 
sublinhados. Aqui estão alguns exemplos de nomes de identificadores corretos e incorretos: 
 
Correto 
count 
test23 
high_balance 
 
Incorreto 
1 count 
hi!there 
high...balance 
 
O padrão C ANSI define que os identificadores em C podem ter qualquer tamanho, mas pelo menos os 
primeiros 6 caracteres devem ser significativos para nomes externos usados em processos de linkedição, e 
31 caracteres para nomes internos. Identificadores que excedem esses limites serão truncados, o que pode 
levar a conflitos de nomes. Em C, letras maiúsculas e minúsculas são tratadas como diferentes e 
identificadores não podem ser palavras-chave do C ou ter o mesmo nome de funções da biblioteca C. 
 
Variáveis 
 
Em C, é necessário declarar as variáveis antes de usá-las, para que o compilador possa reservar a quantidade 
adequada de memória necessária para armazenar os valores. A declaração de variáveis começa com o tipo 
de dado que a variável irá armazenar, seguido pelo nome da variável e, opcionalmente, pelo valor inicial. A 
forma geral de uma declaração é 
 
tipo lista_de_variáveis; 
 
Aqui, tipo deve ser um tipo de dado válido em C mais quaisquer modificadores; e lista_de_variáveis pode 
consistir em um ou mais nomes de identificadores separados por vírgulas. Por exemplo, a declaração "int i, 
j, 1;" declara três variáveis do tipo inteiro com os nomes "i", "j" e "1". A declaração "short int si;" declara uma 
variável do tipo inteiro curto, enquanto "unsigned int ui;" declara uma variável inteira sem sinal. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
18
180
 
 
 
 
É importante notar que o nome da variável não tem relação com seu tipo. Ou seja, você pode escolher 
qualquer nome válido para a variável, independentemente do tipo de dado que ela armazena. No entanto, 
é uma boa prática escolher nomes significativos que reflitam o propósito da variável, para tornar o código 
mais legível e fácil de entender. 
 
Onde as variáveis são declaradas 
 
Em programação, as variáveis podem ser declaradas em três lugares diferentes: dentro de funções, na 
definição de parâmetros de funções e fora de todas as funções. Cada uma dessas opções oferece benefícios 
e limitações, e é importante entender quando e onde declarar suas variáveis para que seu programa funcione 
corretamente. 
 
As variáveis declaradas dentro de uma função são chamadas de variáveis locais. Em C, elas também podem 
ser referidas como variáveis automáticas, pois a palavra-chave "auto" pode ser usada para declará-las. As 
variáveis locais só podem ser referenciadas por comandos que estão dentro do bloco no qual as variáveis 
foram declaradas. Em outras palavras, as variáveis locais não são reconhecidas fora de seu próprio bloco de 
código. 
 
As variáveis locais existem apenas enquanto o bloco de código em que foram declaradas está sendo 
executado. Ou seja, uma variável local é criada na entrada de seu bloco e destruída na saída. O bloco de 
código mais comum em que as variáveis locais são declaradas é a função. Por exemplo, considere as 
seguintes funções: 
 
void minha_funcao() { 
 int variavel_local; 
 // ... 
} 
 
int main() { 
 minha_funcao(); 
 // A variável "variavel_local" não é reconhecida aqui. 
 return 0; 
} 
 
Neste exemplo, a variável "variavel_local" é declarada dentro da função "minha_funcao()" e, portanto, só 
pode ser referenciada dentro desse bloco de código. Ela não é reconhecida fora da função, como pode ser 
visto no "main()". 
 
É importante lembrar que as variáveis locais são destruídas assim que a função em que foram declaradas 
termina de ser executada. Isso significa que, se você precisa armazenar o valor de uma variável para uso 
posterior em outra parte do programa, ela não pode ser declarada como uma variável local. 
 
Em resumo, as variáveis locais são uma opção útil para armazenar valores temporários dentro de uma 
função, sem interferir no resto do programa. No entanto, é importante ter em mente suas limitações e 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
19
180
 
 
 
considerar outras opções quando for necessário armazenar valores por um período mais longo ou fora de 
uma única função. 
 
Variáveis Globais 
 
Ao contrário das variáveis locais, as variáveis globais são reconhecidas pelo programa inteiro e podem ser 
usadas por qualquer pedaço de código. Além disso, elas guardam seus valores durante toda a execução do 
programa. Você cria variáveis globais declarando-as fora de qualquer função. Elas podem ser acessadas por 
qualquer expressão independentemente de qual bloco de código contém a expressão. 
 
#include <stdio.h> 
int count; /* count é global */ 
 
void func1 (void); 
void func2 (void); 
 
void main(void) 
{ 
 count 100; 
 func1(); 
} 
void func1 (void) 
{ 
 int temp; 
 
 temp count; 
 func2(); 
 printf("count é %d", count); /* imprimirá 100 */ 
} 
void func2 (void) 
{ 
 int count; 
 for (count=1; count <10; count++) 
 putchar('.'); 
} 
 
Observe que, apesar de nem main() nem func1() terem declarado a variável count, ambas podem usá-la. A 
função func2(), porém, declarou uma variável local chamada count. Quando func2() referencia count, ela 
referencia apenas sua variável local, não a variável global. Se uma variável global e uma variável local 
possuem o mesmo nome, todas as referências ao nome da variável dentro do bloco onde a variável local foi 
declarada dizem respeito à variável local e não têm efeito algum sobre a variável global. Pode ser 
conveniente, mas esquecer-se disso poderá fazer com que seu programa seja executado estranhamente, 
embora pareça correto. 
 
Paolla Ramos
Aula 03 -Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
20
180
 
 
 
O armazenamento de variáveis globais encontra-se em uma região fixa da memória, separada para esse 
propósito pelo compilador C. Variáveis globais são úteis quando o mesmo dado é usado em muitas funções 
em seu programa. 
 
No entanto, você deve evitar usar variáveis globais desnecessárias. Elas ocupam memória durante todo o 
tempo em que seu programa está executando, não apenas quando são necessárias. Além disso, usar uma 
variável global onde uma variável local poderia ser usada torna uma função menos geral, porque ela conta 
com alguma coisa que deve ser definida fora dela. Finalmente, usar um grande número de variáveis globais 
pode levar a erros no programa por causa de desconhecidos — e indesejáveis — efeitos colaterais. Isso pode 
ser evidenciado no BASIC padrão, em que todas as variáveis são globais. Um problema maior no 
desenvolvimento de grandes projetos é a mudança acidental do valor de uma variável porque ela é usada 
em algum outro lugar do programa. Isso pode acontecer em C se você usar variáveis globais demais em seus 
programas. 
 
Portanto, vimos que, embora as variáveis globais sejam úteis quando o mesmo dado é usado em muitas 
funções em seu programa, é importante evitar usá-las desnecessariamente. Elas ocupam memória durante 
todo o tempo em que o programa está em execução, não apenas quando são necessárias. Além disso, usar 
uma variável global onde uma variável local poderia ser usada torna uma função menos geral, porque ela 
conta com alguma coisa que deve ser definida fora dela. O uso excessivo de variáveis globais pode levar a 
erros no programa devido a efeitos colaterais desconhecidos e indesejáveis. 
 
Parâmetros Formais 
 
Se uma função usa argumentos, ela deve declarar variáveis que receberão os valores dos argumentos. Essas 
variáveis são denominadas parâmetros formais da função. Elas se comportam como qualquer outra variável 
local dentro da função. 
 
Como é mostrado no fragmento de programa seguinte, suas declarações ocorrem depois do nome da função 
e dentro dos parênteses: 
 
/* Retorna 1 se c é parte da string s; 0 se não é o caso */ 
int is_in(char *s, char c) { 
 while (*s) { 
 if (*s == c) { 
 return 1; 
 } 
 s++; 
 } 
 return 0; 
} 
 
A função is_in() tem dois parâmetros: s e c. Essa função devolve 1 se o caractere especificado em c estiver 
contido na string s; 0 se não estiver. Você deve informar à C que tipo de variáveis são os parâmetros formais, 
declarando-os como mostrado acima. Uma vez feito isso, elas podem ser usadas dentro da função como 
variáveis locais normais. Tenha sempre em mente que, como variáveis locais, elas também são dinâmicas e 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
21
180
 
 
 
são destruídas na saída da função. Você deve ter certeza de que os parâmetros formais que estão declarados 
são do mesmo tipo dos argumentos que você utiliza para chamar a função. 
 
Uma das principais razões para uma linguagem estruturada é a compartimentalização ou separação de 
código e dados. Em C, esse isolamento é conseguido pelo uso de variáveis locais e funções. Por exemplo, a 
tabela abaixo mostra duas maneiras de escrever mul() - uma função simples que calcula o produto de dois 
inteiros. 
 
Geral Específica 
mul(int x, int y) 
{ 
return(x*y); 
} 
int x, y; 
mul( void ) 
{ 
return (x*y); 
} 
 
Ambas as funções retornam o produto das variáveis x e y. Contudo, a versão generalizada, ou 
parametrizada, pode ser usada para retornar o produto de quaisquer dois inteiros, enquanto a versão 
específica só pode ser usada para encontrar o produto das variáveis globais x e y. 
 
Modificadores de Tipo de Acesso 
 
O C introduziu dois novos modificadores (também chamados quantificadores) que controlam a maneira 
como as variáveis podem ser acessadas ou modificadas. 
 
Esses modificadores são const e volatile. Devem preceder os modificadores de tipo e os nomes que eles 
modificam. 
 
const 
 
Variáveis do tipo const não podem ser modificadas por seu programa. (Uma variável const pode, entretanto, 
receber um valor inicial.) O compilador pode colocar variáveis desse tipo em memória de apenas leitura 
(ROM). Por exemplo: 
 
const int a=10; 
 
cria uma variável inteira chamada a, com um valor inicial 10, que seu programa não pode modificar. Você 
pode, porém, usar a variável a em outros tipos de expressões. Uma variável const recebe seu valor de uma 
inicialização explícita ou por algum recurso dependente do hardware. 
 
O qualificador "const" protege os objetos apontados pelos argumentos de uma função de serem modificados 
por essa função. Isso é útil para evitar que uma função modifique a variável real apontada pelo ponteiro. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
22
180
 
 
 
O uso do qualificador const em declarações de parâmetros de funções da biblioteca C padrão e em variáveis 
ajuda a proteger objetos de serem modificados por funções e a verificar que o programa não modifica uma 
variável. Quando um argumento é declarado como const, a função não pode modificar o objeto apontado 
pelo argumento. Além disso, o uso de const também ajuda a provar que qualquer alteração em uma variável 
ocorre devido a eventos externos. 
 
volatile 
 
O modificador "volatile" é usado para indicar ao compilador que o valor de uma variável pode ser alterado 
de forma não especificada pelo programa. Isso é importante porque alguns compiladores automaticamente 
otimizam o código, assumindo que o conteúdo de uma variável é imutável, o que pode causar problemas em 
certas situações. 
 
O modificador "volatile" previne essas mudanças. Também é possível usar "const" e "volatile" juntos para 
prevenir efeitos colaterais acidentais. Um exemplo disso seria usar a declaração "const volatile unsigned char 
*port = 0x30" para indicar que o valor de uma porta é mudado apenas por condições externas. 
 
Variáveis static 
 
Dentro de sua própria função ou arquivo, variáveis static são variáveis permanentes. Ao contrário das 
variáveis globais, elas não são reconhecidas fora de sua função ou arquivo, mas mantêm seus valores entre 
chamadas. Essa característica torna-as úteis quando você escreve funções generalizadas e funções de 
biblioteca que podem ser usadas por outros programadores. O especificador static tem efeitos diferentes 
em variáveis locais e em variáveis globais. 
 
Variáveis Locais static 
Quando o modificador static é aplicado a uma variável local, o compilador cria armazenamento permanente 
para ela quase da mesma forma como cria armazenamento para uma variável global. A diferença 
fundamental entre uma variável local static e uma variável global é que a variável local static é reconhecida 
apenas no bloco em que está declarada. Em termos simples, uma variável local static é uma variável local 
que retém seu valor entre chamadas de função. 
 
Variáveis locais static são muito importantes na criação de funções isoladas, porque diversos tipos de rotinas 
devem preservar um valor entre as chamadas. Se variáveis static não fossem permitidas, variáveis globais 
teriam de ser usadas, abrindo brechas para possíveis efeitos colaterais. Um exemplo de função que requer 
uma variável local static é um gerador de série de números que produz um novo número baseado no 
anterior. Seria possível declarar uma variável global parareter esse valor. Porém, cada vez que a função é 
usada, você deve lembrar-se de declarar essa variável global e garantir que ela não conflite com nenhuma 
outra variável global já declarada. Além disso, usar uma variável global tornaria essa função difícil de ser 
colocada em uma biblioteca de funções. 
 
A melhor solução é declarar a variável que retém o número gerado como static, como neste fragmento de 
programa. 
 
series (void) 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
23
180
 
 
 
{ 
 static int series_num; 
 
 series_num = series_num+23; 
 return (series_num); 
} 
 
Nesse exemplo, a variável series_num permanece existindo entre as chamadas da função em vez da criação 
e exclusão que as variáveis locais normais fariam. Isso significa que cada chamada a series() pode produzir 
um novo membro da série, baseado no número precedente, sem declarar essa variável globalmente. 
 
Você pode dar à variável local static um valor de inicialização. Esse valor é atribuído apenas uma vez - e não 
toda vez que o bloco de código é inserido, de forma análoga às variáveis locais normais. Por exemplo, essa 
versão de series() inicializa series_num com 100: 
 
series (void) 
{ 
 static int series_num = 100; 
 
 series_num = series_num+23; 
 return series_num; 
 
} 
 
Da forma como a função se acha agora, a série sempre começa com o valor 123. Enquanto isso é aceitável 
para algumas aplicações, a maioria dos geradores de séries permite ao usuário especificar o ponto inicial. 
Uma maneira de dar a series_num um valor especificado pelo usuário é tornar series_num uma variável 
global e, em seguida, ajustar seu valor de acordo com o especificado. Porém, series_num foi feita static 
justamente para não ser definida como global. Isso leva ao segundo uso de static. 
 
Variáveis Globais static 
 
Aplicar o especificador static a uma variável global informa ao compilador para criar uma variável global que 
é reconhecida apenas no arquivo no qual a mesma foi declarada. Isso significa que, muito embora a variável 
seja global, rotinas em outros arquivos não podem reconhecê-la ou alterar seu conteúdo diretamente; assim, 
não está sujeita a efeitos colaterais. Entretanto, para as poucas situações em que uma variável local static 
não possa fazer o trabalho, você pode criar um pequeno arquivo que contenha apenas as funções que 
precisam da variável global static e compilar separadamente esse arquivo sem medo de efeitos colaterais. 
 
Variáveis register 
 
O especificador de armazenamento register tradicionalmente era aplicado apenas a variáveis dos tipos int e 
char. Contudo, o padrão C ANSI ampliou sua definição de forma que ele pode ser aplicado a qualquer 
variável. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
24
180
 
 
 
Originalmente, o especificador register solicitava ao compilador C que armazenasse o valor das variáveis 
declaradas com esse especificador num registrador da CPU em vez da memória, onde as variáveis normais 
são armazenadas. 
 
Isso significa que operações nas variáveis register poderiam ocorrer muito mais rapidamente que nas 
variáveis armazenadas na memória, pois o valor dessas variáveis era realmente conservado na CPU e não 
era necessário acesso à memória para determinar ou modificar seus valores. 
 
Variáveis 
 
Em C++, existem diferentes tipos de variáveis (definidas com diferentes palavras-chave). Aqui estão mais 
alguns exemplos comuns de tipos de variáveis em C++: 
 
• int- armazena inteiros (números inteiros), sem decimais, como 123 ou -123 
• double- armazena números de ponto flutuante, com decimais, como 19,99 ou -19,99 
• char- armazena caracteres únicos, como 'a' ou 'B'. Os valores de caracteres são cercados por aspas 
simples 
• string- armazena texto, como "Hello World". Os valores de string são colocados entre aspas duplas 
• bool- armazena valores com dois estados: verdadeiro ou falso 
• float - armazena números de ponto flutuante, mas com menos precisão do que o tipo double 
• long - armazena inteiros maiores do que o tipo int, com mais bits de armazenamento 
• short - armazena inteiros menores do que o tipo int, com menos bits de armazenamento 
• unsigned - um modificador que pode ser aplicado a qualquer tipo numérico para permitir apenas 
valores positivos 
 
Existem também vários modificadores que podem ser aplicados a tipos numéricos, como "signed" e 
"unsigned", que afetam se um número pode ser negativo ou não. Além disso, os tipos de variáveis podem 
ser combinados para criar tipos mais complexos, como arrays (matrizes) e structs (estruturas). 
 
Além disso, pessoal, algumas outras informações importantes sobre variáveis em C++: 
 
• As variáveis devem ser declaradas antes de serem usadas. Isso envolve especificar o tipo de dados da 
variável e, opcionalmente, atribuir um valor inicial. 
• As variáveis podem ser inicializadas com um valor durante a declaração, usando o operador de 
atribuição "=". 
• O escopo de uma variável define onde ela pode ser acessada dentro do programa. Variáveis locais 
são definidas dentro de uma função e só podem ser acessadas dentro dessa função. Variáveis globais 
são definidas fora de qualquer função e podem ser acessadas de qualquer lugar no programa. 
• O valor de uma variável pode ser alterado durante a execução do programa, atribuindo um novo valor 
a ela. 
• As variáveis podem ser usadas em expressões matemáticas e em operações lógicas para executar 
cálculos e tomar decisões no programa. 
• É importante inicializar as variáveis antes de usá-las para evitar comportamentos inesperados no 
programa. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
25
180
 
 
 
• As variáveis em C++ são sensíveis a maiúsculas e minúsculas, portanto, "nomeDaVariavel" é diferente 
de "nomedavariavel". 
• Os nomes das variáveis devem ser únicos e descritivos para ajudar a entender o que a variável está 
armazenando. 
 
int myNum = 5; // Integer (whole number without decimals) 
double myFloatNum = 5.99; // Floating point number (with decimals) 
char myLetter = 'D'; // Character 
string myText = "Hello"; // String (text) 
bool myBoolean = true; // Boolean (true or false) 
 
Quando você está trabalhando em um programa que requer muitas variáveis, pode ser tedioso e demorado 
declará-las uma por uma. Em C++, é possível declarar várias variáveis do mesmo tipo usando uma sintaxe 
simplificada. 
 
Por exemplo, em vez de escrever: 
 
int a; 
int b; 
int c; 
int d; 
 
Você pode escrever: 
 
int a, b, c, d; 
 
Esta sintaxe é chamada de declaração de variáveis em linha, onde você pode declarar várias variáveis do 
mesmo tipo na mesma linha, separando-as com vírgulas. Você também pode inicializar várias variáveis na 
mesma linha, como no exemplo abaixo: 
 
int a = 5, b = 10, c = 15, d = 20; 
int a = 5, b, c = 15, d; 
 
Neste exemplo, as variáveis "a" e "c" são inicializadas com valores, enquanto "b" e "d" são declaradas sem 
um valor inicial. Ao declarar várias variáveis em uma linha, é importante manter o código legível, 
certificando-se de que as variáveis estejam separadas por vírgulas e que os nomes das variáveis sejam 
descritivos e fáceis de entender. 
 
Inicialização de Variáveis 
 
Você pode dar à maioria das variáveis em C um valor, no mesmo momento em que elas são declaradas, 
colocando um sinal de igual e uma constanteapós o nome da variável. A forma geral de uma inicialização é 
tipo nome_da_variável = constante; 
 
Alguns exemplos são 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
26
180
 
 
 
 
char ch = 'a'; 
int first = 0; 
float balance = 123.23; 
 
Variáveis globais e variáveis locais static são inicializadas apenas no começo do programa. Variáveis locais 
(incluindo variáveis locais static) são inicializadas cada vez que o bloco no qual estão declaradas for inserido. 
Variáveis locais e register que não são inicializadas possuem valores desconhecidos antes de ser efetuada a 
primeira atribuição a elas. Variáveis globais não inicializadas e variáveis locais estáticas são inicializadas com 
zero. 
 
As formas de inicialização de variáveis em C++ são as seguintes: 
 
• Inicialização implícita: quando uma variável é declarada sem uma atribuição explícita, ela recebe um 
valor padrão que depende do tipo de variável. Por exemplo, um inteiro (int) é inicializado como 0, 
enquanto um ponto flutuante (float) é inicializado como 0.0. 
 
• Inicialização direta: é feita através da atribuição de um valor para a variável no momento da sua 
declaração, utilizando chaves {} ou parênteses (). Por exemplo, para inicializar um inteiro chamado 
"x" com o valor 5, pode-se fazer a declaração "int x = 5;". 
 
• Inicialização por cópia: é feita ao atribuir a uma variável um valor de outra variável já existente, 
utilizando o operador de atribuição "=". 
 
• Inicialização dinâmica: é feita através da alocação dinâmica de memória para uma variável, utilizando 
o operador "new". Isso permite que o valor da variável seja definido em tempo de execução, em vez 
de ser definido em tempo de compilação. 
 
• Inicialização por lista: é feita através da atribuição de valores a uma variável utilizando uma lista de 
inicialização entre chaves {}. Esse método de inicialização permite a atribuição de vários valores a 
uma variável ao mesmo tempo, sendo uma forma mais rápida e eficiente de inicialização em casos 
em que se deseja inicializar vários valores. 
 
Porém, é importante lembrar que a inicialização de variáveis é uma boa prática de programação, mas nem 
sempre é necessária. Em alguns casos, a variável pode ser inicializada em outra parte do código ou receber 
um valor em tempo de execução, durante a execução do programa. 
 
Identificadores 
 
Os identificadores são usados para nomear variáveis, funções, classes, estruturas e outros elementos do 
código. Identificadores são usados para tornar o código mais legível e compreensível. Os identificadores em 
C++ devem seguir as seguintes regras: 
 
• Deve começar com uma letra (maiúscula ou minúscula) ou com um sublinhado (_). 
• Não pode começar com um número. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
27
180
 
 
 
• Pode conter letras, números e sublinhados. 
• Os identificadores são sensíveis a maiúsculas e minúsculas, ou seja, "nome" é diferente de "Nome". 
• O comprimento do identificador é limitado pelo compilador. 
• Algumas palavras-chave reservadas, como "if" e "while", não podem ser usadas como identificadores, 
pois têm um significado especial na linguagem C++. 
 
Além disso, é recomendado usar nomes descritivos para identificadores, para que outros programadores 
possam entender facilmente o que o código está fazendo. Por exemplo, em vez de usar "x" como nome de 
variável, é mais fácil entender o que está acontecendo se você usar um nome mais descritivo, como "idade" 
ou "precoProduto". 
 
Constantes 
 
Em C, constantes referem-se a valores fixos que o programa não pode alterar. Constantes em C podem ser 
de qualquer um dos cinco tipos de dados básicos. A maneira como cada constante é representada depende 
do seu tipo. Constantes de caractere são envolvidas por aspas simples (). Por exemplo, 'a' e '%' são constantes 
tipo caractere. O padrão ANSI também define caracteres multi bytes (usados principalmente em ambientes 
de língua estrangeira). 
 
Constantes inteiras são especificadas como números sem componentes fracionários. Por exemplo, 10 e -100 
são constantes inteiras. Constantes em ponto flutuante requerem o ponto decimal seguido pela parte 
fracionária do número. 
 
Por exemplo, 11.123 é uma constante em ponto flutuante. C também permite que você use notação 
científica para números em ponto flutuante. 
 
É uma boa prática declarar variáveis como constantes quando sabemos que seus valores não mudarão 
durante a execução do programa. Isso ajuda a evitar erros de programação e torna o código mais fácil de ler 
e entender. Por exemplo, podemos declarar constantes como minutosPerHour = 60; e PI = 3.14; e usá-las em 
nossos programas sempre que precisarmos de seus valores, sem nos preocuparmos em alterá-los 
inadvertidamente. 
 
Entrada do usuário 
 
Em C++, a entrada do usuário é obtida por meio da variável predefinida "cin". O operador de extração ">>" 
é usado para armazenar o valor digitado pelo usuário em uma variável. Por exemplo, o código "cin >> x;" 
solicita que o usuário digite um valor que será armazenado na variável "x". Depois disso, podemos usar a 
variável para realizar operações matemáticas ou exibi-la na tela. 
 
Podemos usar a entrada do usuário para criar programas interativos, como uma calculadora simples que 
pede ao usuário para inserir dois números e, em seguida, exibe a soma desses números. Para isso, podemos 
declarar duas variáveis "x" e "y" para armazenar os valores inseridos pelo usuário e outra variável "sum" para 
armazenar o resultado da soma desses valores. Em seguida, usamos "cin" para obter os valores do usuário e 
o operador "+" para somar esses valores. Por fim, exibimos o resultado na tela com a ajuda do operador de 
inserção "<<" e a mensagem "Sum is:". 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
28
180
 
 
 
 
Tipos de dados 
 
Tipos de dados em C/C++ se refere ao tipo de valor que uma variável pode armazenar. O tipo de dado 
determina a quantidade de memória a ser alocada para a variável e as operações que podem ser realizadas 
com ela. O C++ possui diversos tipos de dados integrados, tais como inteiros, números de ponto flutuante, 
caracteres, booleanos, strings, entre outros.. 
 
int myNum = 5; // Integer (whole number) 
float myFloatNum = 5.99; // Floating point number 
double myDoubleNum = 9.98; // Floating point number 
char myLetter = 'D'; // Character 
bool myBoolean = true; // Boolean 
string myText = "Hello"; // String 
 
Tipo de Dado Tamanho Descrição 
boolean 1 byte Armazena valores verdadeiro ou falso 
char 1 byte Armazena um único caractere/letra/número ou valores 
ASCII 
int 2 or 4 bytes Armazena números inteiros sem decimais 
float 4 bytes Armazena números fracionários com uma ou mais casas 
decimais. Suficiente para armazenar 6-7 dígitos decimais 
double 8 bytes Armazena números fracionários com uma ou mais casas 
decimais. Suficiente para armazenar 15 dígitos decimais. 
 
Tipos de dados numéricos 
 
Os tipos numéricos em C++ permitem a declaração e armazenamento de números inteiros e de ponto 
flutuante em variáveis. A escolha do tipo numérico depende do tipo de número que se deseja armazenar. 
 
O tipo int é usado para armazenar números inteiros, sem casas decimais, como 35 ou 1000. Já os tipos float 
e double são usados para armazenar números de ponto flutuante, com casas decimais,como 9.99 ou 
3.14515. O tipo float ocupa 4 bytes de memória, enquanto o tipo double ocupa 8 bytes, permitindo 
armazenar valores com maior precisão. 
 
Além disso, é possível representar números científicos em C++, usando a notação com "e" para indicar a 
potência de 10. Por exemplo, o número 35e3 representa 35 vezes 10 elevado a 3, ou seja, 35000. O número 
12E4 representa 12 vezes 10 elevado a 4, ou seja, 120000. 
 
Tipo Descrição 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
29
180
 
 
 
int 
Tipo de dado numérico inteiro que armazena valores inteiros sem ponto flutuante. 
Ocupa 2 ou 4 bytes na memória e seu intervalo de valores possíveis depende da 
plataforma em que o código está sendo executado. 
int myNum = 1000; 
cout << myNum; 
float 
Tipo de dado numérico em ponto flutuante que armazena valores com uma precisão 
de 6 a 7 dígitos decimais. Ocupa 4 bytes na memória e seu intervalo de valores 
possíveis é de cerca de 1,5 x 10^-45 a 3,4 x 10^38. 
float myNum = 5.75; 
cout << myNum; 
double 
É semelhante ao tipo float, mas oferece uma precisão maior, podendo armazenar 
números reais com uma precisão de cerca de 15 dígitos decimais. Ele usa o dobro 
de espaço de memória que o tipo float. 
double myNum = 19.99; 
cout << myNum; 
 
Tipo de Dados Booleano 
 
Os tipos de dados booleanos são usados para representar valores lógicos, ou seja, valores verdadeiros ou 
falsos. Eles são declarados com a palavra-chave bool e podem ser usados para armazenar apenas os valores 
true ou false. Quando um valor booleano é retornado, true é representado pelo valor 1 e false é 
representado pelo valor 0. 
 
Por exemplo, se você declarar uma variável bool chamada isCodingFun e atribuir o valor true a ela, você pode 
imprimir o valor dessa variável no console usando cout << isCodingFun;. O valor 1 será impresso no console, 
que representa o valor verdadeiro. 
 
Da mesma forma, se você declarar uma variável bool chamada isFishTasty e atribuir o valor false a ela, você 
pode imprimir o valor dessa variável no console usando cout << isFishTasty;. O valor 0 será impresso no 
console, que representa o valor falso. 
 
bool isCodingFun = true; 
bool isFishTasty = false; 
cout << isCodingFun; // Outputs 1 (true) 
cout << isFishTasty; // Outputs 0 (false) 
 
Tipo de Dados Caractere 
 
O tipo de dados char é usado para armazenar um único caractere, que pode ser uma letra, número ou 
símbolo. O caractere deve ser cercado por aspas simples, como 'A' ou 'c': 
 
Exemplo: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
30
180
 
 
 
char myChar = 'A'; 
cout << myChar; // Output: A 
 
Além disso, a tabela ASCII pode ser usada para exibir caracteres específicos por meio de seus valores 
numéricos correspondentes. Exemplo: 
 
char myChar = 65; 
cout << myChar; // Output: A 
 
Note que os valores numéricos correspondem aos caracteres em ordem crescente na tabela ASCII. Além 
disso, os caracteres especiais, como a nova linha e o tabulador, também têm valores numéricos 
correspondentes na tabela ASCII e podem ser armazenados como um tipo de dados char. 
 
Tipos de dados de String 
 
O tipo de dados de string é usado para armazenar uma sequência de caracteres (texto). Este não é um tipo 
integrado, mas se comporta como um em seu uso mais básico. Os valores de string devem ser cercados por 
aspas duplas: 
 
string saudacao = "Olá"; 
cout << saudacao; 
 
Para usar strings, você deve incluir um arquivo de cabeçalho adicional no código-fonte, a biblioteca <string>: 
 
// Inclua a biblioteca de string 
#include <string> 
 
// Crie uma variável de string 
string saudacao = "Olá"; 
 
// Saída do valor da string 
cout << saudacao; 
 
Operadores 
 
Em C++, operadores são usados para realizar operações em variáveis e valores. Existem diversos tipos de 
operadores em C++, incluindo aritméticos, de atribuição, de comparação, lógicos e de bit a bit. Eles permitem 
realizar cálculos matemáticos, atribuir valores a variáveis, comparar valores, realizar operações lógicas e 
trabalhar com dados em nível de bit. No exemplo abaixo, usamos o operador + para adicionar dois valores: 
 
int x = 100 + 50; 
 
Embora o operador + seja frequentemente usado para adicionar dois valores, como no exemplo acima, ele 
também pode ser usado para adicionar uma variável e um valor ou uma variável e outra variável: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
31
180
 
 
 
int sum1 = 100 + 50; // 150 (100 + 50) 
int sum2 = sum1 + 250; // 400 (150 + 250) 
int sum3 = sum2 + sum2; // 800 (400 + 400) 
 
C++ divide os operadores nos seguintes grupos: 
 
• Operadores aritméticos 
• Operadores de atribuição 
• Operadores de comparação 
• Operadores lógicos 
• Operadores bit a bit 
 
Operador Nome Descrição Exemplo 
+ Addition Soma dois valores x + y 
- Subtraction Subtrai um valor de outro x - y 
* Multiplication Multiplica dois valores x * y 
/ Division Dividir um valor por outro x / y 
% Modulus Retorna o restante x % y 
++ Increment Aumenta o valor de uma variável em 1 ++x 
-- Decrement Diminui o valor de uma variável em 1 --x 
 
Os operadores aritméticos são usados para realizar operações matemáticas comuns. São operadores 
utilizados para atribuir valores a variáveis. No exemplo abaixo, utilizamos o operador de atribuição (=) para 
atribuir o valor 10 a uma variável chamada x: 
 
int x; 
x = 10; 
 
Além disso, existem outros tipos de operadores de atribuição combinados com outros operadores 
aritméticos, como +=, -=, *= e /=, que realizam a operação aritmética e atribuem o resultado à variável. Por 
exemplo: 
 
int x = 5; 
x += 3; // o valor de x agora é 8 
x -= 2; // o valor de x agora é 6 
x *= 2; // o valor de x agora é 12 
x /= 3; // o valor de x agora é 4 
 
Operadores de Atribuição 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
32
180
 
 
 
Os assignment operators ou operadores de atribuição são operadores utilizados para atribuir valores a 
variáveis de forma simplificada. Eles combinam um operador aritmético com o operador de atribuição "=" 
para realizar uma operação e atribuir o resultado a uma variável. Por exemplo, o operador "+=" adiciona o 
valor do operando à direita à variável do operando à esquerda e atribui o resultado à variável à esquerda. A 
tabela lista todos os operadores de atribuição em C++ e seu equivalente usando o operador de atribuição 
"=" para ajudar a entender seu funcionamento. 
 
Exemplo Operador Atribuição Igual a 
= x = 5 x = 5 
+= x += 3 x = x + 3 
-= x -= 3 x = x - 3 
*= x *= 3 x = x * 3 
/= x /= 3 x = x / 3 
%= x %= 3 x = x % 3 
&= x &= 3 x = x & 3 
|= x |= 3 x = x | 3 
^= x ^= 3 x = x ^ 3 
>>= x >>= 3 x = x >> 3 
<<= x <<= 3 x = x << 3 
 
Se não conseguiu entender, vamos aprofundar. (Caso tenha entendido, pode pular!) 
 
= é o operador de atribuição que é usado para atribuir um valor a uma variável. 
 
+= é o operador de atribuição de adição que é usado para adicionar um valor a uma variável. 
 
-= é o operador de atribuição de subtração que é usado para subtrair um valor de uma variável. 
 
*= é o operador de atribuição de multiplicação que é usado para multiplicar um valor com uma variável./= é o operador de atribuição de divisão que é usado para dividir uma variável por um valor. 
 
%= é o operador de atribuição de módulo que é usado para atribuir o valor do resto de uma divisão de uma 
variável por outro valor. 
 
&= é o operador de atribuição bitwise AND que é usado para atribuir o resultado de uma operação AND bit 
a bit entre duas variáveis. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
33
180
 
 
 
|= é o operador de atribuição bitwise OR que é usado para atribuir o resultado de uma operação OR bit a bit 
entre duas variáveis. 
 
^= é o operador de atribuição bitwise XOR que é usado para atribuir o resultado de uma operação XOR bit a 
bit entre duas variáveis. 
 
>>= é o operador de atribuição bitwise de deslocamento à direita que é usado para deslocar à direita o valor 
de uma variável por um número específico de bits. 
 
<<= é o operador de atribuição bitwise de deslocamento à esquerda que é usado para deslocar à esquerda 
o valor de uma variável por um número específico de bits. 
 
Operadores de Comparação 
 
Operadores de Comparação são usados para comparar dois valores (ou variáveis) em C++. Esses operadores 
são importantes em programação, pois nos ajudam a encontrar respostas e tomar decisões em nossos 
códigos. 
 
Os operadores de comparação retornam um valor booleano, que é representado por 1 (verdadeiro) ou 0 
(falso). Esses valores são conhecidos como valores booleanos, e você aprenderá mais sobre eles no capítulo 
de Booleans e If..Else. 
 
No exemplo a seguir, usamos o operador de maior que (>) para descobrir se 5 é maior que 3: 
 
int x = 5; 
int y = 3; 
cout << (x > y); // Output: 1 (verdadeiro) 
 
Além do operador de maior que (>), existem outros operadores de comparação em C++, tais como: 
 
• Menor que (<) 
• Maior ou igual a (>=) 
• Menor ou igual a (<=) 
• Igual a (==) 
• Diferente de (!=) 
 
Você pode usar esses operadores em expressões condicionais para controlar o fluxo do seu programa. Por 
exemplo: 
 
 
int x = 5; 
int y = 3; 
if (x > y) { 
 cout << "x é maior que y" << endl; 
} else { 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
34
180
 
 
 
 cout << "x é menor ou igual a y" << endl; 
} 
 
Este código irá imprimir "x é maior que y", já que a expressão x > y é verdadeira. 
 
Operador 
Comparação 
Nome Exemplo 
== Igual a x == y 
!= Não igual x != y 
> Maior que x > y 
< Menor que x < y 
>= Maior ou igual a x >= y 
<= Menor ou igual a x <= y 
 
Operadores Lógicos 
 
Assim como os operadores de comparação, você também pode testar valores verdadeiros (1) ou falsos (0) 
com operadores lógicos. Os operadores lógicos são usados para determinar a lógica entre variáveis ou 
valores: 
 
Logical Operators (Operadores Lógicos) são usados em programação para testar se duas ou mais condições 
são verdadeiras ou falsas. Existem três tipos de operadores lógicos em C++: 
 
• AND lógico (&&): Retorna verdadeiro se todas as condições testadas forem verdadeiras. 
• OR lógico (||): Retorna verdadeiro se pelo menos uma das condições testadas for verdadeira. 
• NOT lógico (!): Inverte o resultado da condição. Se a condição é verdadeira, retorna falso e vice-versa. 
 
Esses operadores são muito úteis em estruturas de controle de fluxo, como estruturas if-else, loops while e 
do-while que veremos ainda nessa aula! 
 
Operador Nome2 Descrição Exemplo 
&& Lógico e 
Retorna verdadeiro se 
ambas as declarações 
forem verdadeiras 
x < 5 && x < 10 
|| Lógico ou 
Retorna verdadeiro se 
uma das declarações for 
verdadeira 
x < 5 || x < 4 
 
2 Pode-se usar apenas e, ou e não – desconsiderando a palavra ‘Lógico’. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
35
180
 
 
 
! Lógico não 
Inverte o resultado, 
retorna falso se o 
resultado for verdadeiro 
!(x < 5 && x < 10) 
 
Strings 
 
Strings são tipos de dados que permitem armazenar e manipular sequências de caracteres, ou seja, textos. 
Em C++, a classe "string" é usada para representar strings, ou seja, sequências de caracteres, e é uma parte 
da biblioteca padrão da linguagem. 
 
Para declarar uma variável string em C++, basta usar o tipo "string" e atribuir a ela uma sequência de 
caracteres delimitada por aspas duplas. 
 
Por exemplo: 
 
#include <string> 
 
using namespace std; 
 
string nome = "João"; 
 
Note que é necessário incluir a biblioteca <string> no seu código para usar strings em C++. As strings também 
possuem diversas funções e operadores que podem ser usados para manipular e comparar as sequências de 
caracteres armazenadas nelas. 
 
Concatenação de String 
 
Em C++, a concatenação de strings é a operação de adicionar duas ou mais strings juntas para formar uma 
nova string. Isso é feito usando o operador de adição (+) ou o método append(). 
 
O operador de adição (+) é usado para adicionar duas strings e criar uma nova string concatenada. Por 
exemplo, se tivermos duas strings str1 e str2, podemos usar o operador de adição (+) para juntá-las em uma 
nova string str3 da seguinte maneira: str3 = str1 + str2;. É importante lembrar que ao usar o operador de 
adição com strings, devemos garantir que cada string esteja envolvida em aspas duplas. 
 
string firstName = "John "; 
string lastName = "Doe"; 
string fullName = firstName + lastName; 
cout << fullName; 
 
No exemplo acima, adicionamos um espaço após firstName para criar um espaço entre John e Doe na saída. 
No entanto, você também pode adicionar um espaço com aspas ( " "ou ' '): 
 
string firstName = "John"; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
36
180
 
 
 
string lastName = "Doe"; 
string fullName = firstName + " " + lastName; 
cout << fullName; 
 
Em C++, o append é uma função membro da classe std::string que adiciona uma string ao final de outra. É 
equivalente ao operador de concatenação (+), mas em vez de criar um novo objeto de string, ele modifica o 
objeto existente. A função retorna uma referência ao objeto de string modificado. 
 
A sintaxe básica para usar append é a seguinte: 
std::string str1 = "Hello, "; 
std::string str2 = "world!"; 
str1.append(str2); // adiciona str2 ao final de str1 
 
Após a execução do código acima, str1 conterá a string "Hello, world!". Observe que a função append 
modifica o objeto de string str1 em vez de criar um novo objeto. Também é possível adicionar substrings 
usando a função append com índices de início e fim: 
 
std::string str1 = "Hello, "; 
std::string str2 = "world!"; 
str1.append(str2, 0, 3); // adiciona os primeiros três caracteres de str2 ao 
final de str1 
 
Após a execução do código acima, str1 conterá a string "Hello, wor". Nesse exemplo, a função append 
adiciona os primeiros três caracteres da string str2 ao final da string str1, começando do índice 0 (ou seja, o 
primeiro caractere) e adicionando três caracteres no total. 
 
Portanto, o método append() adiciona uma string a outra string existente. Em vez de criar uma nova string 
como o operador de adição, o append() adiciona uma string a outra string existente. 
 
Outro exemplo, se tivermos uma string str1 e uma string str2, podemos usar o método append() para 
adicionar str2 ao final de str1 da seguintemaneira: str1.append(str2);. O método append() pode ser usado 
para adicionar várias strings à string existente. 
 
Números e Strings C++ 
 
Ao tentar adicionar um número a uma string em C++, ocorre um erro porque esses tipos de dados são 
diferentes e o operador + é sobrecarregado para diferentes finalidades, dependendo dos tipos de operandos 
que recebe. Para adicionar um número a uma string, é necessário converter o número em uma string 
primeiro, usando uma função de conversão, como to_string() ou stringstream. 
 
int x = 10; 
string y = "The value of x is: " + to_string(x); 
cout << y; // Outputs: The value of x is: 10 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
37
180
 
 
 
Nesse exemplo, o valor da variável x é convertido em uma string usando a função to_string() e, em seguida, 
concatenado com a string "The value of x is: " usando o operador +. O resultado final é uma string que contém 
a mensagem "The value of x is: 10". 
 
Explicando melhor: a função to_string() é uma função em C++ que converte um número em uma string. Ela 
faz parte da biblioteca padrão e pode ser útil em muitas situações, especialmente quando se deseja mesclar 
valores numéricos e strings. 
 
Comprimento da String 
 
Em C++, para obter o comprimento de uma string, você pode usar a função length() ou size(). Ambas as 
funções retornam o número de caracteres em uma string. 
 
Por exemplo, suponha que você tenha a string "Olá mundo!" e queira saber quantos caracteres ela contém: 
 
#include <iostream> 
#include <string> 
 
using namespace std; 
 
int main() { 
 string texto = "Olá mundo!"; 
 int comprimento = texto.length(); 
 int tamanho = texto.size(); 
 
 cout << "Comprimento: " << comprimento << endl; 
 cout << "Tamanho: " << tamanho << endl; 
 
 return 0; 
} 
 
O programa acima usa tanto a função length() quanto size() para obter o comprimento da string "Olá 
mundo!". O resultado será: 
 
Comprimento: 10 
Tamanho: 10 
 
Observe que, neste caso, ambas as funções retornaram o mesmo valor. Isso ocorre porque length() e size() 
são equivalentes em C++. 
 
Acessar Strings 
 
Em C++, você pode acessar os caracteres de uma string se referindo ao seu número de índice dentro de 
colchetes []. Por exemplo, suponha que você tenha a string "Olá mundo!" e queira imprimir o terceiro 
caractere (índice 2): 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
38
180
 
 
 
#include <iostream> 
#include <string> 
 
using namespace std; 
 
int main() { 
 string texto = "Olá mundo!"; 
 
 cout << texto[2] << endl; 
 
 return 0; 
} 
 
O programa acima acessa o terceiro caractere da string "Olá mundo!" (índice 2) usando o operador de 
colchetes [] e o imprime na tela. O resultado será: 
 
á 
 
Observe que o índice começa em 0, ou seja, o primeiro caractere é o índice 0, o segundo é o índice 1, e assim 
por diante. Você também pode acessar vários caracteres de uma string usando um loop for, como mostrado 
no exemplo a seguir: 
 
#include <iostream> 
#include <string> 
 
using namespace std; 
 
int main() { 
 string texto = "Olá mundo!"; 
 
 for (int i = 0; i < texto.length(); i++) { 
 cout << texto[i] << endl; 
 } 
 
 return 0; 
} 
 
Este programa imprime cada caractere da string "Olá mundo!" em uma linha separada. Ele usa um loop for 
para iterar através da string e o operador de colchetes [] para acessar cada caractere individual. O resultado 
será: 
 
O 
l 
á 
 
m 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
39
180
 
 
 
u 
n 
d 
o 
! 
 
Matemática C++ 
 
Em C++, existem várias funções matemáticas disponíveis para realizar cálculos em números. Algumas dessas 
funções são: 
 
• max(x,y): retorna o valor máximo entre x e y. 
• min(x,y): retorna o valor mínimo entre x e y. 
• sqrt(x): retorna a raiz quadrada de x. 
• round(x): arredonda o número x para o inteiro mais próximo. 
• log(x): retorna o logaritmo natural de x. 
 
Para usar essas funções em um programa C++, é necessário incluir o cabeçalho <cmath>. Por exemplo, 
suponha que você queira encontrar a raiz quadrada de um número e arredondá-lo para o inteiro mais 
próximo: 
 
#include <iostream> 
#include <cmath> 
 
using namespace std; 
 
int main() { 
 double num = 16.7; 
 int resultado = round(sqrt(num)); 
 
 cout << "A raiz quadrada de " << num << " é " << sqrt(num) << endl; 
 cout << "Arredondado para o inteiro mais próximo: " << resultado << endl; 
 
 return 0; 
} 
 
O programa acima usa as funções sqrt() e round() para encontrar a raiz quadrada de um número e arredondá-
lo para o inteiro mais próximo. O resultado será: 
 
A raiz quadrada de 16.7 é 4.08248 
Arredondado para o inteiro mais próximo: 4 
 
Observe que, neste exemplo, o resultado da função sqrt() foi arredondado usando a função round() antes de 
ser impresso na tela. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
40
180
 
 
 
Outras funções matemáticas 
 
Uma lista de outras funções matemáticas populares (da biblioteca <cmath>) pode ser encontrada na tabela 
abaixo: 
 
Função Descrição 
abs(x) Retorna o valor absoluto de x 
acos(x) Retorna o arco cosseno de x 
asin(x) Retorna o arco-seno de x 
atan(x) Retorna o arco tangente de x 
cbrt(x) Retorna a raiz cúbica de x 
ceil(x) Retorna o valor de x arredondado para o número inteiro mais próximo 
cos(x) Retorna o cosseno de x 
cosh(x) Retorna o cosseno hiperbólico de x 
exp(x) Retorna o valor da exponencial de um número x. 
expm1(x) Retorna ex -1, onde "e" é a constante de Euler 
fabs(x) Retorna o valor absoluto de um x flutuante 
fdim(x, y) Retorna a diferença positiva entre x e y 
floor(x) Retorna o valor de x arredondado para baixo para o inteiro mais próximo 
hypot(x, y) Retorna sqrt(x2 +y2) sem estouro ou estouro intermediário 
fma(x, y, z) Retorna x*y+z sem perder a precisão 
fmax(x, y) Retorna o valor mais alto de x e y flutuantes 
fmin(x, y) Retorna o valor mais baixo de x e y flutuantes 
fmod(x, y) Retorna o ponto flutuante restante de x/y 
pow(x, y) Retorna o valor de x elevado a y 
sin(x) Retorna o seno de x (x está em radianos) 
sinh(x) Retorna o seno hiperbólico de um valor duplo 
tan(x) Retorna a tangente de um ângulo 
tanh(x) Retorna a tangente hiperbólica de um valor duplo 
 
Se você conseguiu entender as funções listadas, pode ir para o próximo tópico, senão aqui darei mais 
algumas considerações. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
41
180
 
 
 
 
• abs(x): Retorna o valor absoluto de x. Ou seja, se x for um número negativo, o resultado será o seu 
valor positivo correspondente. Por exemplo, abs(-5) retorna 5. 
 
• acos(x): Retorna o arco-cosseno de x em radianos. O valor de x deve estar entre -1 e 1, caso contrário, 
o resultado será NaN (Not a Number). O resultado da função é um ângulo em radianos cujo cosseno 
é x. Por exemplo, acos(0.5) retorna o valor de pi/3 (cerca de 1.0472 radianos). 
 
• asin(x):Retorna o arco-seno de x em radianos. O valor de x deve estar entre -1 e 1, caso contrário, o 
resultado será NaN. O resultado da função é um ângulo em radianos cujo seno é x. Por exemplo, 
asin(0.5) retorna o valor de pi/6 (cerca de 0.5236 radianos). 
 
• atan(x): Retorna o arco-tangente de x em radianos. O resultado da função é um ângulo em radianos 
cuja tangente é x. Por exemplo, atan(1) retorna o valor de pi/4 (cerca de 0.7854 radianos). 
 
• cbrt(x): Retorna a raiz cúbica de x. Por exemplo, cbrt(8) retorna 2. 
 
• ceil(x): Retorna o menor número inteiro maior ou igual a x. Por exemplo, ceil(4.3) retorna 5. 
 
• cos(x): Retorna o cosseno de x em radianos. Por exemplo, cos(0) retorna 1. 
 
• cosh(x): Retorna o cosseno hiperbólico de x. Por exemplo, cosh(0) retorna 1. 
 
• exp(x): Retorna o valor de e^x, onde e é a constante de Euler (cerca de 2.71828). Por exemplo, exp(1) 
retorna o valor de e (cerca de 2.71828). Explico melhor no fim dessa sessão 
 
• expm1(x): Retorna o valor de e^x - 1, onde e é a constante de Euler. Essa função é útil quando se 
trabalha com números muito pequenos, onde a subtração de 1 pode ser calculada com maior 
precisão do que a própria exponencial. Por exemplo, expm1(1) retorna o valor de e - 1 (cerca de 
1.71828). 
 
• fabs(x): Retorna o valor absoluto de x, mas para valores de ponto flutuante. Ou seja, se x for um 
número negativo, o resultado será o seu valor positivo correspondente, mas sem mudar o tipo de 
dados. Por exemplo, fabs(-5.5) retorna 5.5. 
 
• fdim(x, y): Retorna a diferença entre x e y se x for maior que y, e retorna 0 caso contrário. Por 
exemplo, fdim(5, 3) retorna 2. 
 
• floor(x)retorna o maior número inteiro menor ou igual ax. Por exemplo, floor(3.7)retorna3, enquanto 
floor(-2.9)retorna-3`. 
 
• hypot(x, y): Retorna a hipotenusa de um triângulo retângulo com catetos x e y. Por exemplo, hypot(3, 
4) retorna 5. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
42
180
 
 
 
• fma(x, y, z): Retorna o produto de x e y somado a z. É útil para evitar a perda de precisão durante o 
cálculo de expressões algébricas. Por exemplo, fma(2, 3, 4) retorna 10. 
 
• fmax(x, y): Retorna o maior valor entre x e y. Por exemplo, fmax(5, 3) retorna 5. 
 
• fmin(x, y): Retorna o menor valor entre x e y. Por exemplo, fmin(5, 3) retorna 3. 
 
• fmod(x, y): Retorna o resto da divisão de x por y. Por exemplo, fmod(10, 3) retorna 1. 
 
• pow(x, y): Retorna x elevado à potência y. Por exemplo, pow(2, 3) retorna 8. 
 
• sin(x): Retorna o seno de um ângulo em radianos. Por exemplo, sin(0) retorna 0. 
 
• sinh(x): Retorna o seno hiperbólico de um número. Por exemplo, sinh(0) retorna 0. 
 
• tan(x): Retorna a tangente de um ângulo em radianos. Por exemplo, tan(0) retorna 0. 
 
• tanh(x): Retorna a tangente hiperbólica de um número. Por exemplo, tanh(0) retorna 0. 
 
Em C++, a função "exp(x)" retorna o valor da exponencial de um número x. A constante e (número de Euler) 
é elevada à potência de x, ou seja, exp(x) = e^x. Por exemplo, exp(2) retorna o valor de e elevado à potência 
de 2, que é aproximadamente 7,389. Para usar a função "exp(x)" em um programa C++, é necessário incluir 
o cabeçalho <cmath>. 
 
Já a função "expm1(x)" retorna o valor de ex - 1. Isso significa que o valor da exponencial é calculado primeiro 
e, em seguida, 1 é subtraído do resultado. Essa função é útil quando o valor de ex é muito próximo de 1, pois 
a subtração de 1 pode ser calculada com mais precisão do que a exponencial em si. Para usar a função 
"expm1(x)" em um programa C++, também é necessário incluir o cabeçalho <cmath>. 
 
C++ Booleans 
 
Muito frequentemente, na programação, você precisará de um tipo de dado que possa ter apenas um de 
dois valores, como: 
 
SIM / NÃO 
LIGADO / DESLIGADO 
VERDADEIRO / FALSO 
 
Para isso, o C++ possui um tipo de dados bool, que pode receber os valores verdadeiro (1) ou falso (0). Uma 
variável booleana é declarada com a palavra-chave bool e só pode receber os valores true ou false: 
 
bool estaChovendo = true; 
bool estaFrio = false; 
cout << estaChovendo; // Saída: 1 (true) 
cout << estaFrio; // Saída: 0 (false) 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
43
180
 
 
 
 
As variáveis booleanas são frequentemente usadas em estruturas de controle de fluxo, como os condicionais 
"if...else", onde a decisão de executar um bloco de código é baseada em uma condição booleana: 
 
bool estaChovendo = true; 
if (estaChovendo) { 
cout << "Pegue um guarda-chuva"; 
} else { 
cout << "Não se esqueça do seu óculos de sol"; 
} 
 
O código verifica se a variável estaChovendo é verdadeira (true) e, caso seja verdadeira, imprime "Pegue um 
guarda-chuva". Se a variável for falsa (false), o código imprime "Não se esqueça do seu óculos de sol". 
 
Boolean Expressions em C++ 
 
Boolean Expression (Expressão Booleana) é uma expressão que retorna um valor booleano, que pode ser 
verdadeiro (1) ou falso (0). Essa expressão é útil para construir lógica e encontrar respostas em um programa. 
 
Você pode usar operadores de comparação, como o operador maior que (>) ou igual a (>=), para verificar se 
uma expressão ou variável é verdadeira ou falsa. 
 
int x = 10; 
int y = 9; 
cout << (x > y); // retorna 1 (verdadeiro), porque 10 é maior do que 9 
cout << (10 > 9); // retorna 1 (verdadeiro), porque 10 é maior do que 9 
 
No exemplo abaixo, usamos o operador igual a (==) para avaliar uma expressão: 
 
int x = 10; 
cout << (x == 10); // retorna 1 (verdadeiro), porque o valor de x é igual a 10 
cout << (10 == 15); // retorna 0 (falso), porque 10 não é igual a 15 
 
Agora vejamos um exemplo na vida real: Vamos pensar em um exemplo da vida real onde precisamos 
descobrir se uma pessoa é maior de idade e pode votar. No exemplo, usamos o operador maior ou igual a 
(>=) para descobrir se a idade (25) é maior ou igual ao limite de idade para votar, que é de 18 anos: 
 
int minhaIdade = 25; 
int idadeParaVotar = 18; 
 
cout << (minhaIdade >= idadeParaVotar); /* retorna 1 (verdadeiro), o que 
significa que pessoas com 25 anos podem votar! */ 
 
Uma abordagem ainda melhor seria envolver o código acima em um if...else statement, para que possamos 
executar ações diferentes dependendo do resultado. Veremos isso a seguir! 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
44
180
 
 
 
Estruturas de Controle de Fluxo 
 
Em programação, as estruturas de controle de fluxo são usadas para alterar o fluxo de execução de um 
programa, permitindo que o código seja executado de maneira condicional ou repetitiva. Em C++, existem 
três tipos principais de estruturas de controle de fluxo: as estruturas de seleção (if/else), as estruturas de 
repetição (for, while, do-while) e a estrutura de controle de interrupção (break/continue). 
 
As estruturas de seleção permitem que o programa execute um bloco de código se uma condição for 
verdadeira e outro bloco de código se a condição for falsa. 
 
If...Else 
 
O If...Else é uma estrutura de controle de fluxo em C++ que permite ao programador executar um bloco de 
código somente se uma condição for verdadeira, e outro bloco de código caso a condição seja falsa. 
 
if (condicao) { 
 // código a ser executado se a condição for verdadeira 
} else { 
 // código a ser executado se a condição for falsa 
} 
 
Por exemplo, suponha que queremos escrever um programaque verifica se um número é par ou ímpar: 
 
#include <iostream> 
using namespace std; 
 
int main() { 
 int numero; 
 cout << "Digite um número: "; 
 cin >> numero; 
 
 if (numero % 2 == 0) { 
 cout << "O número é par" << endl; 
 } else { 
 cout << "O número é ímpar" << endl; 
 } 
 
 return 0; 
} 
Nesse programa, o usuário é solicitado a digitar um número e a seguir é verificado se ele é par ou ímpar. Se 
o número for divisível por 2, ou seja, se o resto da divisão por 2 for igual a 0, então a condição dentro do if é 
verdadeira e o programa exibe a mensagem "O número é par". Caso contrário, a condição dentro do else é 
verdadeira e o programa exibe a mensagem "O número é ímpar". Também é possível usar múltiplas 
condições usando o else if: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
45
180
 
 
 
#include <iostream> 
using namespace std; 
 
int main() { 
 int idade; 
 cout << "Digite sua idade: "; 
 cin >> idade; 
 
 if (idade < 18) { 
 cout << "Você é menor de idade" << endl; 
 } else if (idade < 60) { 
 cout << "Você é adulto" << endl; 
 } else { 
 cout << "Você é idoso" << endl; 
 } 
 
 return 0; 
} 
 
Nesse exemplo, o programa verifica a idade do usuário e exibe uma mensagem diferente de acordo com a 
faixa etária. Se a idade for menor que 18, a mensagem "Você é menor de idade" é exibida. Se a idade for 
maior ou igual a 18 e menor que 60, a mensagem "Você é adulto" é exibida. Caso contrário, a mensagem 
"Você é idoso" é exibida. 
 
A declaração "else" é usada em programação para especificar um bloco de código a ser executado se a 
condição for falsa. Por exemplo, se quisermos verificar se uma pessoa é maior de idade, podemos escrever 
o seguinte código: 
 
int idade = 20; 
if (idade >= 18) { 
 cout << "Esta pessoa é maior de idade."; 
} else { 
 cout << "Esta pessoa é menor de idade."; 
} 
 
Neste exemplo, se a idade for maior ou igual a 18, o programa imprimirá "Esta pessoa é maior de idade". 
Caso contrário, o programa imprimirá "Esta pessoa é menor de idade". Outro exemplo seria se quisermos 
verificar se um número é par ou ímpar: 
int numero = 5; 
if (numero % 2 == 0) { 
 cout << "Este número é par."; 
} else { 
 cout << "Este número é ímpar."; 
} 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
46
180
 
 
 
Neste exemplo, se o resto da divisão do número por 2 for igual a zero, o programa imprimirá "Este número 
é par". Caso contrário, o programa imprimirá "Este número é ímpar". 
 
Já, a declaração "else if" é usada em programação para especificar uma nova condição se a primeira condição 
for falsa. A sintaxe é a seguinte: 
 
if (condição1) { 
 // bloco de código a ser executado se a condição1 for verdadeira 
} else if (condição2) { 
 // bloco de código a ser executado se a condição1 for falsa e condição2 for 
verdadeira 
} else { 
 // bloco de código a ser executado se a condição1 e a condição2 forem falsas 
} 
 
Por exemplo, se quisermos imprimir uma mensagem de acordo com a hora do dia, podemos escrever o 
seguinte código: 
 
int hora = 14; 
if (hora < 10) { 
 cout << "Bom dia."; 
} else if (hora < 20) { 
 cout << "Boa tarde."; 
} else { 
 cout << "Boa noite."; 
} 
 
Neste exemplo, se a hora for menor que 10, o programa imprimirá "Bom dia". Se a hora estiver entre 10 e 
20, o programa imprimirá "Boa tarde". Caso contrário, o programa imprimirá "Boa noite". 
 
Outro exemplo seria se quisermos atribuir uma nota de acordo com a pontuação de um aluno em um teste: 
 
int pontuacao = 75; 
if (pontuacao >= 90) { 
 cout << "Nota A."; 
} else if (pontuacao >= 80) { 
 cout << "Nota B."; 
} else if (pontuacao >= 70) { 
 cout << "Nota C."; 
} else if (pontuacao >= 60) { 
 cout << "Nota D."; 
} else { 
 cout << "Nota F."; 
} 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
47
180
 
 
 
Neste exemplo, se a pontuação for maior ou igual a 90, o programa imprimirá "Nota A". Se a pontuação 
estiver entre 80 e 89, o programa imprimirá "Nota B". Se a pontuação estiver entre 70 e 79, o programa 
imprimirá "Nota C". Se a pontuação estiver entre 60 e 69, o programa imprimirá "Nota D". Caso contrário, o 
programa imprimirá "Nota F". 
 
O operador ternário (short-hand if else) em C++ é uma forma abreviada de escrever uma estrutura de seleção 
if/else em uma única linha de código. Ele consiste em três operandos: a condição, a expressão a ser 
executada se a condição for verdadeira e a expressão a ser executada se a condição for falsa. A sintaxe do 
operador ternário é a seguinte: 
 
variavel = (condição) ? expressãoVerdadeira : expressãoFalsa; 
 
Se a condição for verdadeira, a expressãoVerdadeira é executada, caso contrário a expressãoFalsa é 
executada. Por exemplo, para o seguinte código em if/else: 
 
int idade = 20; 
if (idade >= 18) { 
 cout << "Você é maior de idade"; 
} else { 
 cout << "Você é menor de idade"; 
} 
 
Podemos usar o operador ternário para escrever o mesmo código em uma única linha: 
 
int idade = 20; 
string resultado = (idade >= 18) ? "Você é maior de idade" : "Você é menor de 
idade"; 
cout << resultado; 
 
Isso torna o código mais conciso e fácil de ler. No entanto, é importante lembrar que o uso excessivo do 
operador ternário pode tornar o código difícil de entender e manter, especialmente para iniciantes. 
 
Switch 
 
A declaração Switch em C++ é usada para selecionar um entre vários blocos de código a serem executados. 
A sintaxe da declaração switch inclui uma expressão, que é avaliada uma vez, e vários casos, cada um dos 
quais corresponde a um valor diferente que a expressão pode ter. Quando a expressão é avaliada, o valor é 
comparado com os valores de cada caso. Se houver uma correspondência, o bloco de código associado a 
esse caso é executado. 
 
Por exemplo, se quisermos imprimir o nome do dia da semana em relação ao número do dia da semana, 
podemos usar a instrução switch: 
 
int dia = 4; 
switch (dia) { 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
48
180
 
 
 
 case 1: 
 cout << "Segunda-feira"; 
 break; 
 case 2: 
 cout << "Terça-feira"; 
 break; 
 case 3: 
 cout << "Quarta-feira"; 
 break; 
 case 4: 
 cout << "Quinta-feira"; 
 break; 
 case 5: 
 cout << "Sexta-feira"; 
 break; 
 case 6: 
 cout << "Sábado"; 
 break; 
 case 7: 
 cout << "Domingo"; 
 break; 
} 
// Saída: "Quinta-feira" (dia 4) 
 
A declaração switch é seguida pelos casos, cada um dos quais inclui um valor e um bloco de código a ser 
executado se a expressão for igual a esse valor. O bloco de código associado a cada caso é seguido pela 
palavra-chave break. Quando um caso é executado, o break interrompe a execução dos casos restantes na 
declaração switch. Se nenhum dos casos corresponder à expressão, a palavra-chave default especifica um 
bloco de código padrão a ser executado. 
 
While 
 
O loop While (enquanto) é uma estrutura de repetição em que um bloco de código é executado 
repetidamente enquanto uma condição especificada for verdadeira. A sintaxe em C++ para um loop While é 
a seguinte: 
 
while (condição) { 
 // bloco de código a ser executado 
} 
 
O bloco de código dentro doloop será executado repetidamente enquanto a condição especificada for 
verdadeira. Quando a condição se tornar falsa, o loop será encerrado e a execução continuará no próximo 
bloco de código após o loop. 
 
Aqui está um exemplo simples em C++ que usa um loop While para imprimir os números de 0 a 4: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
49
180
 
 
 
int i = 0; 
while (i < 5) { 
 cout << i << "\n"; 
 i++; 
} 
 
Neste exemplo, a variável i é inicializada como 0 e o loop continuará a ser executado enquanto i for menor 
que 5. Dentro do loop, o valor atual de i é impresso na tela e, em seguida, i é incrementado em 1 antes de 
verificar a condição novamente. Quando i atinge 5, a condição se torna falsa e o loop é encerrado. A saída 
deste programa seria: 
 
0 
1 
2 
3 
4 
 
Este é um exemplo simples, mas o loop While pode ser usado para executar qualquer bloco de código 
repetidamente enquanto uma condição for verdadeira. 
 
Do/While 
 
O laço do/While é uma variação do laço While. A principal diferença é que o código dentro do laço é 
executado pelo menos uma vez, independentemente da condição definida. Em seguida, a condição é 
verificada e o laço será executado novamente, se a condição for verdadeira. 
 
do { 
// código a ser executado 
} while (condição); 
 
#include <iostream> 
using namespace std; 
 
int main() { 
 int i = 0; 
 do { 
 cout << i << "\n"; 
 i++; 
 } 
 while (i < 5); 
 return 0; 
} 
 
Neste exemplo, o código dentro do laço será executado pelo menos uma vez, já que a condição é verificada 
após a primeira execução. Se a condição for verdadeira, o laço será executado novamente, e assim por 
diante, até que a condição se torne falsa. O resultado do exemplo será: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
50
180
 
 
 
 
0 
1 
2 
3 
4 
 
Vejamos agora a diferença entre While e o do/While. O código apresentado abaixo é um exemplo de uso dos 
loops "while" e "do/while" em C++. Esses loops são usados para executar uma ação repetidamente enquanto 
uma condição especificada for verdadeira. 
 
O loop "while" é uma estrutura de controle de fluxo que executa um bloco de código enquanto uma 
determinada condição é verdadeira. A condição é verificada antes de executar o bloco de código. Se a 
condição for falsa, o bloco de código não será executado. 
 
O loop "do/while", por outro lado, executa o bloco de código pelo menos uma vez e, em seguida, verifica a 
condição para determinar se o bloco de código deve ser executado novamente. Se a condição for verdadeira, 
o bloco de código será executado novamente e o processo continuará até que a condição seja falsa. 
 
#include <iostream> 
 
int main() { 
 // Exemplo utilizando o loop while 
 int i = 1; 
 int soma_while = 0; 
 while (i <= 10) { 
 soma_while += i; 
 i++; 
 } 
 std::cout << "A soma utilizando o loop while é: " << soma_while << std::endl; 
 
 // Exemplo utilizando o loop do/while 
 int j = 1; 
 int soma_do_while = 0; 
 do { 
 soma_do_while += j; 
 j++; 
 } while (j <= 10); 
 std::cout << "A soma utilizando o loop do/while é: " << soma_do_while << 
std::endl; 
 
 return 0; 
} 
 
O resultado das somas utilizando os dois loops são iguais, que é 55, a soma dos números inteiros de 1 a 10. 
No entanto, a principal diferença entre os dois loops é que o loop while avalia a condição antes de executar 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
51
180
 
 
 
o bloco de código, o que significa que o bloco de código pode nunca ser executado se a condição for falsa 
desde o início. Por outro lado, o loop do/while executa o bloco de código pelo menos uma vez, antes de 
avaliar a condição. 
 
Se você já entendeu, pode passar para o próximo tópico, senão, vamos entender melhor! No exemplo, o 
programa solicita ao usuário para digitar um número inteiro positivo e, em seguida, usa os loops "while" e 
"do/while" para exibir os números de 1 a n na tela, onde n é o número digitado pelo usuário. 
 
No exemplo apresentado, a diferença entre os loops "while" e "do/while" é que, se o usuário digitar um 
número negativo, o loop "while" não será executado, pois a condição "num > 0" é falsa. Por outro lado, o 
loop "do/while" executará o bloco de código pelo menos uma vez, independentemente da condição, o que 
significa que a mensagem "Número inválido!" será exibida pelo menos uma vez. 
 
For 
 
O loop For é uma estrutura de controle que permite executar um bloco de código várias vezes, com base em 
uma condição específica. É um dos loops mais utilizados na programação, principalmente quando se sabe de 
antemão quantas vezes o loop precisa ser executado. 
 
O loop For possui uma sintaxe padrão, que é composta por três partes: inicialização, condição e atualização. 
Abaixo está a sintaxe completa do loop For em C++: 
 
for (inicialização; condição; atualização) { 
 // código a ser executado 
} 
 
• Inicialização: Define e/ou inicializa a variável do contador. Esta parte é executada apenas uma vez, 
no início do loop. 
• Condição: Define a condição que será verificada a cada iteração do loop. Se a condição for verdadeira, 
o loop continuará a ser executado; caso contrário, o loop será encerrado. 
• Atualização: Atualiza a variável do contador a cada iteração. Essa parte é executada no final de cada 
iteração do loop. 
 
Vejamos um exemplo: 
 
for (int i = 0; i < 5; i++) { 
 cout << i << endl; 
} 
 
Nesse exemplo, a variável do contador é i, que é inicializada com 0. A condição é i < 5, o que significa que o 
loop continuará a ser executado enquanto i for menor que 5. A atualização é i++, o que significa que i será 
incrementado em 1 a cada iteração do loop. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
52
180
 
 
 
O loop For é especialmente útil quando você sabe exatamente quantas vezes o loop precisa ser executado. 
Ele também é mais conciso do que o loop While ou o loop Do-While, pois você pode definir todas as três 
partes do loop na linha de cabeçalho. 
 
Break and Continue 
 
Em C++, o break e o continue são palavras-chave usadas em loops para controlar o fluxo de execução do 
código. 
 
O break é usado para interromper a execução de um loop imediatamente quando uma condição específica 
é atendida. Quando o break é encontrado dentro de um loop, a execução do loop é interrompida e o controle 
é transferido para a próxima instrução após o loop. 
 
Já o continue é usado para pular a execução de uma iteração do loop quando uma determinada condição é 
atendida. Quando o continue é encontrado dentro de um loop, a execução da iteração atual é interrompida 
e o loop continua com a próxima iteração. 
 
Vejamos um exemplo de como essas palavras-chave são usadas em loops em C++: 
 
// Exemplo usando break 
for (int i = 0; i < 10; i++) { 
 if (i == 5) { 
 break; 
 } 
 std::cout << i << std::endl; 
} 
// Output: 0 1 2 3 4 
 
// Exemplo usando continue 
for (int i = 0; i < 10; i++) { 
 if (i == 5) { 
 continue; 
 } 
 std::cout << i << std::endl; 
} 
// Output: 0 1 2 3 4 6 7 8 9 
 
No primeiro exemplo, quando i atinge o valor 5, a condição i == 5 é atendida e o break é executado, 
interrompendo o loop eimpedindo a execução de todas as iterações seguintes. 
 
Já no segundo exemplo, quando i atinge o valor 5, a condição i == 5 é atendida e o continue é executado, 
pulando a execução da iteração atual e continuando com a próxima iteração. 
 
Em resumo, o break é usado para interromper um loop imediatamente, enquanto o continue é usado para 
pular a execução de uma iteração do loop e continuar com a próxima. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
53
180
 
 
 
Array 
 
Em C++, um array é uma coleção de elementos do mesmo tipo de dados, armazenados em uma área contígua 
de memória. Cada elemento no array pode ser acessado por um índice, que começa em 0 e vai até o tamanho 
do array menos um. A declaração básica de um array em C++ é: 
 
tipo_de_dado nome_do_array[tamanho]; 
 
Por exemplo, um array de inteiros com 5 elementos pode ser declarado assim: 
 
int meu_array[5]; 
 
Cada elemento do array pode ser acessado e modificado usando o operador [] e o índice correspondente: 
 
meu_array[0] = 42; 
meu_array[1] = 17; 
meu_array[2] = 8; 
meu_array[3] = 33; 
meu_array[4] = 99; 
 
Os elementos do array também podem ser inicializados na declaração: 
 
int meu_array[] = {42, 17, 8, 33, 99}; 
 
Os elementos do array podem ser acessados usando loops, como o for loop. Por exemplo, o seguinte código 
imprime todos os elementos do array: 
 
for (int i = 0; i < 5; i++) { 
 cout << meu_array[i] << " "; 
} 
 
A saída seria: "42 17 8 33 99". Os arrays são muito úteis quando se deseja armazenar e manipular grandes 
quantidades de dados do mesmo tipo de dados. No entanto, é importante garantir que o índice usado para 
acessar o array esteja dentro dos limites válidos do array, para evitar erros de segmentação. 
 
Arrays e Loops 
 
Loop através de um array em C++ é uma tarefa muito comum e útil para processar todos os elementos de 
um array. Existem várias maneiras de percorrer um array em C++, incluindo loops for, while e do-while. 
 
Vamos ver alguns exemplos. Exemplo 1: Usando loop for 
 
Suponha que temos um array de inteiros e queremos imprimir todos os elementos do array. Podemos fazer 
isso usando um loop for da seguinte forma: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
54
180
 
 
 
#include <iostream> 
 
using namespace std; 
 
int main() { 
 int nums[] = {2, 4, 6, 8, 10}; 
 
 for(int i = 0; i < 5; i++) { 
 cout << nums[i] << " "; 
 } 
 
 return 0; 
} 
 
Neste exemplo, declaramos um array de inteiros chamado nums com 5 elementos. Usando um loop for, 
imprimimos cada elemento do array. 
 
Exemplo 2: Usando loop while. Podemos usar um loop while para percorrer um array em C++ da seguinte 
maneira: 
 
#include <iostream> 
 
using namespace std; 
 
int main() { 
 int nums[] = {2, 4, 6, 8, 10}; 
 int i = 0; 
 
 while(i < 5) { 
 cout << nums[i] << " "; 
 i++; 
 } 
 
 return 0; 
} 
 
Neste exemplo, inicializamos a variável i como 0 e usamos um loop while para imprimir cada elemento do 
array. Incrementamos a variável i a cada iteração do loop até que ela seja maior ou igual a 5. 
 
Exemplo 3: Usando loop do-while. Podemos usar um loop do-while para percorrer um array em C++ da 
seguinte maneira: 
 
#include <iostream> 
 
using namespace std; 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
55
180
 
 
 
int main() { 
 int nums[] = {2, 4, 6, 8, 10}; 
 int i = 0; 
 
 do { 
 cout << nums[i] << " "; 
 i++; 
 } while(i < 5); 
 
 return 0; 
} 
 
Neste exemplo, inicializamos a variável i como 0 e usamos um loop do-while para imprimir cada elemento 
do array. Incrementamos a variável i a cada iteração do loop até que ela seja maior ou igual a 5. 
 
Em resumo, percorrer um array em C++ é uma tarefa comum e útil. Usando loops for, while e do-while, 
podemos processar todos os elementos do array de maneira fácil e eficiente. 
 
Structures (struct) 
 
Em C++, uma struct é uma coleção de variáveis de diferentes tipos que são agrupadas sob um nome. Ela é 
uma estrutura de dados que permite armazenar e manipular dados relacionados. Uma struct pode ser 
definida da seguinte maneira: 
 
struct Pessoa { 
 string nome; 
 int idade; 
 float altura; 
}; 
 
Nesse exemplo, definimos uma estrutura chamada Pessoa que contém três variáveis: nome do tipo string, 
idade do tipo int e altura do tipo float. Uma vez definida a struct, podemos criar variáveis com base nela: 
 
Pessoa pessoa1 = {"João", 30, 1.75}; 
 
Agora pessoa1 é uma variável do tipo Pessoa que contém os valores "João" para o nome, 30 para a idade e 
1.75 para a altura. Podemos acessar as variáveis da struct usando o operador ponto .: 
 
cout << "Nome: " << pessoa1.nome << endl; 
cout << "Idade: " << pessoa1.idade << endl; 
cout << "Altura: " << pessoa1.altura << endl; 
 
Isso exibirá o conteúdo de cada variável da struct. As structs são frequentemente usadas em conjunto com 
loops para armazenar e manipular conjuntos de dados. Por exemplo, podemos criar um array de Pessoa: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
56
180
 
 
 
Pessoa pessoas[3] = { 
 {"João", 30, 1.75}, 
 {"Maria", 25, 1.60}, 
 {"Pedro", 35, 1.80} 
}; 
 
Podemos, então, percorrer esse array usando um loop for: 
 
for(int i=0; i<3; i++) { 
 cout << "Nome: " << pessoas[i].nome << endl; 
 cout << "Idade: " << pessoas[i].idade << endl; 
 cout << "Altura: " << pessoas[i].altura << endl; 
} 
 
Isso exibirá o conteúdo de cada variável da struct para cada elemento do array pessoas. 
 
 
 
 
 
 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
57
180
RESUMO 
 
C é uma linguagem de programação de alto nível, criada na década de 1970 por Dennis Ritchie. É uma 
linguagem estruturada, de tipagem estática e com suporte para apontadores. Ela é amplamente usada para 
desenvolvimento de sistemas operacionais, compiladores, dispositivos embarcados, aplicações de rede, 
jogos, entre outras aplicações. É uma linguagem de programação bastante eficiente, com recursos de baixo 
nível que permitem aos programadores otimizar a performance do código. Além disso, C é uma linguagem 
de programação portátil, o que significa que o código escrito em C pode ser compilado e executado em 
diferentes plataformas. Por ser uma linguagem de programação amplamente utilizada, há uma grande 
quantidade de bibliotecas e ferramentas disponíveis para facilitar o desenvolvimento de aplicações em C. 
 
O C++ é uma extensão da linguagem C, adicionando recursos como a programação orientada a objetos, 
sobrecarga de operadores, templates e exceções, tornando-o mais poderoso e flexível do que o C. Embora 
tenha se originado do C, o C++ não é totalmente compatível com ele. A evolução do C++ continuou, com a 
adição de novos recursos e aprimoramento dos existentes. O C é amplamente utilizado na programação de 
sistemas, enquanto o C++ é frequentemente usado na programação de aplicativos, jogos e outras aplicações 
complexas. O C requer compilação antes da execução, tem variáveis com tipos,operadores para cálculos, 
estruturas de controle para controlar o fluxo do programa, funções para dividir o código em partes menores 
e mais gerenciáveis, e bibliotecas para realizar tarefas específicas. 
 
Comparativo C C++ 
Paradigma Procedural Procedural, orientada a objetos 
Compilação Código fonte compilado em 
arquivo .c 
Código fonte compilado em arquivo .cpp 
Alocação de memória Uso de funções como malloc e 
calloc 
Uso de operadores como new e delete 
Herança Não suporta Suporta 
Polimorfismo Não suporta Suporta, com classes abstratas e virtuais 
Exceções Não suporta Suporta, com try e catch 
Sobrecarga de 
operadores 
Não suporta Suporta 
Biblioteca padrão Possui biblioteca padrão 
limitada, incluindo stdio.h e 
math.h 
Possui biblioteca padrão mais extensa, 
incluindo iostream, string e algorithm 
Utilização Amplamente utilizado na 
programação de sistemas, 
sistemas embarcados e outros 
projetos de baixo nível 
Amplamente utilizado na programação de 
aplicativos, jogos, softwares de alta 
performance e projetos que requerem 
programação orientada a objetos 
 
Vejamos os Tipos Básicos de Dados 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
58
180
 
Tipo 
Tamanho aproximado 
em bits 
Faixa Mínima 
char 8 -127 a 127 
unsigned char 8 0 a 255 
signed char 8 -127 a 127 
int 16 -32.767 a 32.767 
unsigned int 16 0 a 65.535 
signed int 16 O mesmo que int 
short int 16 O mesmo que int 
unsigned short int 16 0 a 65.535 
signed short int 16 O mesmo que short int 
long int 32 -2.147.483.647 a 2.147.483.647 
signed long int 32 O mesmo que long int. 
unsigned long int 32 0 a 4.294.967.295 
float 32 Seis dígitos de precisão 
double 64 Dez dígitos de precisão 
long double 80 Dez dígitos de precisão 
 
Modificar os Tipos Básicos em C e C++ envolve a criação de tipos personalizados que são baseados nos tipos 
existentes da linguagem. Isso pode ser feito usando estruturas (structs) e enums (enumerações), bem como 
a criação de novos tipos com typedef. 
 
Estruturas (structs) são usadas para agrupar variáveis de diferentes tipos em uma única unidade lógica. Elas 
são úteis para representar entidades complexas, como uma pessoa ou um objeto em um jogo. As structs em 
C++ também podem ter funções e métodos associados a elas, tornando-as parte integrante da programação 
orientada a objetos. 
 
Enums (enumerações) são usados para definir um conjunto de valores inteiros nomeados. Eles são úteis para 
representar um conjunto limitado de valores possíveis, como as cores de um semáforo ou os dias da semana. 
Em C++, as enumerações podem ter um tipo subjacente específico, bem como métodos e funções 
associados. 
 
O typedef é usado para criar novos tipos de dados que são baseados nos tipos existentes, permitindo que o 
programador crie nomes mais descritivos para esses tipos. Por exemplo, em vez de usar "unsigned int" para 
representar um número não negativo, pode-se criar um typedef "word" para isso. Isso torna o código mais 
legível e mais fácil de entender. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
59
180
A tabela abaixo resume as diferenças entre as estruturas, enums e typedef em C e C++: 
 
Comparação Estruturas (structs) Enums (enumerações) Typedef 
Finalidade Agrupar variáveis em 
uma unidade lógica 
Definir um conjunto 
limitado de valores 
nomeados 
Criar um novo nome 
para um tipo de dados 
existente 
Sintaxe struct nome { /* 
membros */ }; 
enum nome { /* 
membros */ }; 
typedef tipo 
novo_nome; 
Acesso a membros Usar o operador "." N/A N/A 
Métodos associados Não em C, sim em C++ Não em C, sim em C++ N/A 
Subtipo de int Não Sim Não 
 
Em resumo, modificar os tipos básicos em C e C++ permite que o programador crie tipos personalizados que 
atendam às necessidades específicas do programa. Isso pode tornar o código mais legível e mais fácil de 
entender, além de fornecer uma maneira de agrupar variáveis relacionadas e definir conjuntos limitados de 
valores nomeados. As estruturas, enums e typedef são ferramentas importantes para alcançar esses 
objetivos. 
 
As variáveis em programação são utilizadas para armazenar valores na memória e são identificadas por um 
nome único. Existem vários tipos de variáveis, cada uma com suas próprias características e escopos. 
 
Aqui estão algumas explicações sobre as variáveis em C e C++: 
 
Static: uma variável estática é uma variável que mantém seu valor entre chamadas de função. Ela é 
inicializada apenas uma vez na primeira chamada da função em que foi declarada e, em seguida, seu valor é 
mantido nas chamadas subsequentes da função. Variáveis estáticas são definidas com a palavra-chave 
"static". Elas têm escopo local por padrão, mas também podem ser definidas como globais. 
 
Global static: uma variável estática global é uma variável que mantém seu valor entre chamadas de função 
em todo o programa. Ela é inicializada apenas uma vez no início da execução do programa e, em seguida, 
seu valor é mantido em todo o programa. Variáveis estáticas globais são definidas no nível de arquivo com a 
palavra-chave "static". 
 
Register: uma variável de registro é uma variável que é armazenada em um registrador de CPU, em vez de 
na memória. Ela é usada para otimizar o desempenho do programa, pois o acesso a registradores é mais 
rápido do que o acesso à memória. No entanto, o compilador pode decidir não armazenar a variável em um 
registrador, caso não haja registradores disponíveis ou se a variável não for usada com frequência. Variáveis 
de registro são definidas com a palavra-chave "register". Elas têm escopo local por padrão. 
 
É importante lembrar que o uso excessivo de variáveis estáticas e globais pode tornar o programa mais difícil 
de ler e entender, já que o valor da variável pode ser alterado em diferentes partes do programa. Além disso, 
o uso excessivo de variáveis de registro pode levar a um aumento do tamanho do código, o que pode reduzir 
o desempenho do programa em alguns casos. Por isso, é importante usar essas variáveis com cuidado e 
apenas quando necessário. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
60
180
 
Em C++, é possível inicializar a maioria das variáveis com um valor no momento em que são declaradas, 
usando o sinal de igual e uma constante após o nome da variável. As variáveis globais e locais static são 
inicializadas apenas no início do programa, enquanto as variáveis locais são inicializadas cada vez que o bloco 
no qual estão declaradas é inserido. Variáveis locais e register que não são inicializadas têm valores 
desconhecidos antes da primeira atribuição, enquanto variáveis globais e locais static não inicializadas são 
inicializadas com zero. 
 
Constantes em C++ são valores que não podem ser alterados durante a execução do programa. Existem dois 
tipos de constantes: constantes literais e constantes simbólicas. As constantes literais são valores fixos, como 
números e caracteres. As constantes simbólicas são definidas pelo programador usando a diretiva #define 
ou a palavra-chave const. 
 
Identificadores em C++ são usados para dar nome a variáveis, funções, estruturas, classes, etc. Os 
identificadores podem conter letras, dígitos e o caractere underscore (_), mas devem começar com uma letra 
ou underscore. Eles também devem ser únicos dentro de um escopo. 
 
C++ possui diversos tipos de dados, como int, float, double, char, bool, entreoutros. Os tipos de dados 
definem o tamanho e o tipo de valor que uma variável pode armazenar. 
 
int myNum = 5; // Integer (whole number) 
float myFloatNum = 5.99; // Floating point number 
double myDoubleNum = 9.98; // Floating point number 
char myLetter = 'D'; // Character 
bool myBoolean = true; // Boolean 
string myText = "Hello"; // String 
 
Tipo de Dado Tamanho Descrição 
boolean 1 byte Armazena valores verdadeiro ou falso 
char 1 byte Armazena um único caractere/letra/número ou valores 
ASCII 
int 2 or 4 bytes Armazena números inteiros sem decimais 
float 4 bytes Armazena números fracionários com uma ou mais casas 
decimais. Suficiente para armazenar 6-7 dígitos decimais 
double 8 bytes Armazena números fracionários com uma ou mais casas 
decimais. Suficiente para armazenar 15 dígitos decimais. 
 
Operadores em C++ são símbolos que realizam operações em variáveis e valores. Existem diversos tipos de 
operadores em C++, como aritméticos (+, -, *, /), de atribuição (=), relacionais (==, !=, <, >, <=, >=), lógicos 
(&&, ||, !), entre outros. Cada tipo de operador tem uma função específica. 
 
 
Operador Nome Descrição Exemplo 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
61
180
+ Addition Soma dois valores x + y 
- Subtraction Subtrai um valor de outro x - y 
* Multiplication Multiplica dois valores x * y 
/ Division Dividir um valor por outro x / y 
% Modulus Retorna o restante x % y 
++ Increment Aumenta o valor de uma variável em 1 ++x 
-- Decrement Diminui o valor de uma variável em 1 --x 
 
 
Exemplo Operador Atribuição Igual a 
= x = 5 x = 5 
+= x += 3 x = x + 3 
-= x -= 3 x = x - 3 
*= x *= 3 x = x * 3 
/= x /= 3 x = x / 3 
%= x %= 3 x = x % 3 
&= x &= 3 x = x & 3 
|= x |= 3 x = x | 3 
^= x ^= 3 x = x ^ 3 
>>= x >>= 3 x = x >> 3 
<<= x <<= 3 x = x << 3 
 
 
 
Operador 
Comparação 
Nome Exemplo 
== Igual a x == y 
!= Não igual x != y 
> Maior que x > y 
< Menor que x < y 
>= Maior ou igual a x >= y 
<= Menor ou igual a x <= y 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
62
180
 
 
Operador 
Lógico 
Nome1 Descrição Exemplo 
&& Lógico e 
Retorna verdadeiro se 
ambas as declarações 
forem verdadeiras 
x < 5 && x < 10 
|| Lógico ou 
Retorna verdadeiro se 
uma das declarações for 
verdadeira 
x < 5 || x < 4 
! Lógico não 
Inverte o resultado, 
retorna falso se o 
resultado for verdadeiro 
!(x < 5 && x < 10) 
 
Em C++, strings são utilizadas para armazenar e manipular sequências de caracteres, ou seja, textos. É 
possível declarar variáveis string usando o tipo "string" e atribuindo a ela uma sequência de caracteres 
delimitada por aspas duplas. É possível concatenar strings utilizando o operador de adição (+) ou o método 
append(). 
 
Para adicionar um número a uma string, é necessário converter o número em uma string primeiro, usando 
uma função de conversão, como to_string() ou stringstream. Para obter o comprimento de uma string, é 
possível utilizar as funções length() ou size(). 
 
Matemática C++ 
 
Em C++, existem várias funções matemáticas disponíveis para realizar cálculos em números. Algumas dessas 
funções são: 
 
• max(x,y): retorna o valor máximo entre x e y. 
• min(x,y): retorna o valor mínimo entre x e y. 
• sqrt(x): retorna a raiz quadrada de x. 
• round(x): arredonda o número x para o inteiro mais próximo. 
• log(x): retorna o logaritmo natural de x. 
 
Estrutura de Controle de Fluxo 
 
A estrutura de controle de fluxo "if...else" é usada em programação para executar uma ação com base em 
uma condição booleana. Se a condição booleana especificada no "if" for verdadeira, o bloco de código dentro 
do "if" será executado. Caso contrário, o bloco de código dentro do "else" será executado. É possível usar 
várias cláusulas "else if" para testar várias condições antes do bloco de código "else". A estrutura "if...else" 
é útil para fazer escolhas em tempo de execução com base em certas condições. 
 
 
1 Pode-se usar apenas e, ou e não – desconsiderando a palavra ‘Lógico’. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
63
180
Switch é uma estrutura de controle de fluxo em C++ que permite executar diferentes blocos de código 
dependendo do valor de uma expressão. A expressão é comparada com valores constantes definidos em 
cada case e o bloco de código correspondente ao valor da expressão é executado. O switch é geralmente 
usado como uma alternativa mais clara e organizada a várias declarações if-else aninhadas. 
 
While e Do-While são estruturas de repetição em linguagens de programação que permitem executar um 
conjunto de instruções várias vezes, até que uma condição seja atendida. A principal diferença entre as duas 
estruturas é a ordem em que a condição é verificada. 
 
Na estrutura While, a condição é verificada antes de executar as instruções dentro do loop. Se a condição 
for verdadeira, as instruções são executadas; caso contrário, o loop é encerrado. Já na estrutura Do-While, 
as instruções são executadas pelo menos uma vez, antes de verificar a condição. Se a condição for 
verdadeira, o loop continua a ser executado; caso contrário, o loop é encerrado. 
 
A tabela comparativa abaixo resume as principais diferenças entre as duas estruturas: 
 
Comparação While Do-While 
Ordem de Execução Verifica a condição antes de 
executar as instruções 
Executa as instruções pelo 
menos uma vez antes de 
verificar a condição 
Pode executar nenhuma vez? Sim, se a condição for falsa no 
início. 
Não, pelo menos uma execução 
garantida. 
Adequado para casos em que O loop pode não ser executado, 
e a condição deve ser verificada 
primeiro. 
O loop deve ser executado pelo 
menos uma vez, 
independentemente da 
condição. 
 
Em resumo, a estrutura While é adequada para casos em que o loop pode não ser executado, e a condição 
deve ser verificada primeiro, enquanto a estrutura Do-While é adequada para casos em que o loop deve ser 
executado pelo menos uma vez, independentemente da condição. 
Estrutura Descrição 
if 
Executa um bloco de código somente se uma condição especificada for 
verdadeira. 
if-else 
Executa um bloco de código se uma condição especificada for verdadeira e 
outro bloco de código se a condição for falsa. 
if-else if-else 
Executa um bloco de código se a primeira condição especificada for 
verdadeira, se não, verifica outra condição e assim por diante. 
switch 
Executa um bloco de código dependendo do valor de uma variável ou 
expressão. 
while 
Executa um bloco de código enquanto uma condição especificada for 
verdadeira. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
64
180
do-while 
Executa um bloco de código pelo menos uma vez e, em seguida, continua a 
executá-lo enquanto uma condição especificada for verdadeira. 
for 
Executa um bloco de código um número específico de vezes, com base em 
uma inicialização, uma condição de teste e uma atualização de contador. 
break 
Sai de uma estrutura de loop. 
 
continue 
Pula para a próxima iteração de uma estrutura de loop. 
 
 
Array é uma estrutura de dados utilizada em programação para armazenar um conjunto de valores do 
mesmo tipo sob um único nomede variável. Cada valor armazenado em um array é identificado por um 
índice numérico que representa sua posição no array. Em C++, os arrays podem ser uni ou multidimensionais. 
 
• Declaração de arrays: Um array é declarado especificando seu tipo de dados, nome da variável e seu 
tamanho (quantidade de elementos). Exemplo: int numeros[10]; cria um array de 10 elementos do 
tipo inteiro chamado "numeros". 
 
• Acesso aos elementos do array: Para acessar um elemento específico do array, você precisa 
especificar o índice correspondente entre colchetes após o nome do array. Exemplo: numeros[3] 
acessa o quarto elemento do array "numeros". 
 
• Inicialização de arrays: Em C++, você pode inicializar um array durante a declaração usando uma lista 
de valores entre chaves. Exemplo: int numeros[] = {1, 2, 3, 4, 5}; cria um array de tamanho 5 chamado 
"numeros" com os valores especificados. 
 
• Iteração sobre arrays: Para percorrer todos os elementos de um array, você pode usar um loop for 
com um contador que varia de 0 até o tamanho do array - 1. Exemplo: 
 
int numeros[5] = {1, 2, 3, 4, 5}; 
for (int i = 0; i < 5; i++) { 
 std::cout << numeros[i] << std::endl; 
} 
 
• Arrays multidimensionais: Em C++, você pode criar arrays com mais de uma dimensão. Por exemplo, 
uma matriz de tamanho 3x3 pode ser declarada como int matriz[3][3]; e seus elementos podem ser 
acessados usando dois índices. Exemplo: matriz[1][2] acessa o elemento da segunda linha e terceira 
coluna da matriz. 
 
• Ponteiros e arrays: Em C++, um array é essencialmente um ponteiro para seu primeiro elemento na 
memória. Você pode usar aritmética de ponteiros para acessar os outros elementos do array. 
Exemplo: *(numeros + 3) é equivalente a numeros[3]. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
65
180
==30e709==
• Tamanho do array: Em C++, o tamanho de um array é fixo durante a compilação e pode ser obtido 
usando a função sizeof. Exemplo: sizeof(numeros) retorna o número de bytes ocupados pelo array 
"numeros". 
 
Vamos ver agora alguns algoritmos mais cobrados em provas. 
 
• Bubble Sort: É um algoritmo simples de ordenação que compara cada par de elementos adjacentes 
e troca-os de posição, se necessário. Esse processo é repetido várias vezes até que a lista esteja 
ordenada. É fácil de implementar, mas não é muito eficiente em termos de tempo de execução. 
 
• Insertion Sort: É um algoritmo de ordenação que percorre a lista de elementos e, para cada elemento, 
insere-o na posição correta na lista ordenada anteriormente. É mais eficiente que o Bubble Sort em 
termos de tempo de execução, mas ainda não é o mais rápido. 
 
• Selection Sort: É um algoritmo de ordenação que percorre a lista de elementos e, para cada elemento, 
encontra o menor elemento restante na lista e o troca com o elemento atual. É fácil de entender, 
mas não é tão eficiente em termos de tempo de execução quanto outros algoritmos. 
 
• Quick Sort: É um algoritmo de ordenação eficiente e amplamente utilizado. Ele escolhe um elemento 
como pivô e organiza os elementos ao seu redor em duas partições, uma com elementos menores 
que o pivô e outra com elementos maiores. O processo é repetido recursivamente até que toda a 
lista esteja ordenada. 
 
• Merge Sort: É um algoritmo de ordenação eficiente e divide a lista em duas metades iguais, ordena 
cada metade e, em seguida, mescla as duas metades em uma única lista ordenada. É um algoritmo 
"dividir e conquistar" e é bastante eficiente em termos de tempo de execução. 
 
• Heap Sort: É um algoritmo de ordenação que usa uma estrutura de dados conhecida como heap para 
organizar os elementos. Ele cria um heap a partir da lista não ordenada e extrai o elemento máximo 
repetidamente para construir a lista ordenada. É eficiente em termos de tempo de execução e é 
frequentemente usado em aplicações de grande escala. 
 
O selection sort é um algoritmo de ordenação que funciona da seguinte maneira: 
 
1. Percorre todo o vetor a ser ordenado, buscando o menor elemento. 
2. Troca esse menor elemento com o primeiro elemento do vetor. 
3. Percorre o restante do vetor, a partir do segundo elemento, buscando o menor elemento. 
4. Troca esse menor elemento com o segundo elemento do vetor. 
5. Repete os passos 3 e 4 para cada posição do vetor, até que todos os elementos estejam ordenados. 
6. O algoritmo é chamado de "selection sort" (ordenação por seleção) porque a cada passo, ele 
seleciona o menor elemento restante no vetor e o coloca na posição correspondente. 
 
O selection sort é um algoritmo simples e fácil de entender, mas possui uma complexidade de tempo de 
execução de O(n^2), o que significa que ele pode ser bastante ineficiente para vetores grandes. 
 
Segue um exemplo de implementação do selection sort em C++: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
66
180
void selection_sort(int arr[], int n) { 
 for (int i = 0; i < n-1; i++) { 
 int min_idx = i; 
 for (int j = i+1; j < n; j++) { 
 if (arr[j] < arr[min_idx]) { 
 min_idx = j; 
 } 
 } 
 if (min_idx != i) { 
 swap(arr[i], arr[min_idx]); 
 } 
 } 
} 
 
Nessa implementação, a função selection_sort recebe um vetor arr de tamanho n como parâmetro e o 
ordena usando o selection sort. A função swap é usada para trocar os elementos de posição no vetor. O 
algoritmo percorre o vetor arr duas vezes: uma para encontrar o menor elemento e outra para trocá-lo de 
posição com o elemento atual. Isso é feito para cada posição do vetor, resultando em uma ordenação 
completa do vetor. 
 
Selection sort: 
 
1. Percorre todo o vetor a ser ordenado, buscando o menor elemento. 
2. Troca esse menor elemento com o primeiro elemento do vetor. 
3. Percorre o restante do vetor, a partir do segundo elemento, buscando o menor elemento. 
4. Troca esse menor elemento com o segundo elemento do vetor. 
5. Repete os passos 3 e 4 para cada posição do vetor, até que todos os elementos estejam ordenados. 
 
O algoritmo é chamado de "selection sort" (ordenação por seleção) porque a cada passo, ele seleciona o 
menor elemento restante no vetor e o coloca na posição correspondente. 
 
Bubble sort: 
 
1. Percorre todo o vetor, comparando pares de elementos adjacentes. 
2. Se um par estiver fora de ordem, troca os elementos de posição. 
3. Repete os passos 1 e 2 para cada par de elementos no vetor, até que nenhum par esteja mais fora de 
ordem. 
 
O algoritmo é chamado de "bubble sort" (ordenação por bolha) porque os elementos maiores "flutuam" para 
o topo do vetor como bolhas em um líquido. 
 
Insertion sort: 
 
1. Percorre todo o vetor, considerando um elemento de cada vez. 
2. Insere cada elemento na posição correta em uma sublista ordenada do vetor. 
3. A sublista ordenada começa com o primeiro elemento do vetor e cresce a cada passo do algoritmo. 
4. Repete os passos 1 e 2 para cada elemento do vetor, até que todos os elementos estejam na sublista 
ordenada. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
67
180
 
O algoritmo é chamado de "insertion sort" (ordenação por inserção) porque insere cada elemento na posição 
correta da sublista ordenada. 
 
Merge sort: 
 
1. Divide o vetor a ser ordenado em duas metades iguais. 
2. Recursivamente ordena cada metade usando o mesmo algoritmo (merge sort). 
3. Combina as duas metades ordenadasem um único vetor ordenado. 
O algoritmo é chamado de "merge sort" (ordenação por mesclagem) porque mescla duas listas ordenadas 
em uma única lista ordenada. 
 
Quick sort: 
 
1. Escolhe um elemento do vetor como pivô (geralmente o primeiro ou o último elemento). 
2. Reorganiza o vetor de forma que todos os elementos menores que o pivô estejam à esquerda e todos 
os elementos maiores estejam à direita. 
3. Recursivamente ordena a metade esquerda e a metade direita do vetor usando o mesmo algoritmo 
(quick sort). 
 
O algoritmo é chamado de "quick sort" (ordenação rápida) porque geralmente é mais rápido do que outros 
algoritmos de ordenação, especialmente para conjuntos de dados grandes. 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
68
180
QUESTÕES COMENTADAS 
Diversas Bancas 
 
1. (VUNESP – UNICAMP – 2022) Na linguagem C++, estruturas (definidas pela palavra-chave struct) podem 
ser passadas como parâmetros em chamadas de funções. Nesse contexto, assinale a alternativa correta. 
 
a) Por padrão, estruturas são passadas por referência. 
b) Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por 
valor requer que a estrutura inteira seja copiada. 
c) Estruturas só podem ser passadas como parâmetro por meio do uso de ponteiros. 
d) É necessário o uso da palavra-chave inline na declaração da função que recebe uma estrutura como 
parâmetro. 
e) Apenas funções do tipo void podem receber estruturas como parâmetros. 
 
Comentários: 
 
Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por valor 
requer que a estrutura inteira seja copiada. Isso pode ser custoso em termos de desempenho se a estrutura 
for grande. Portanto, é comum passar estruturas por referência ou por ponteiros para evitar a cópia 
desnecessária de dados. No entanto, é importante notar que é possível passar estruturas por valor se a 
estrutura for pequena e se a cópia não afetar significativamente o desempenho da função. A letra A está 
incorreta, pois as estruturas podem ser passadas por valor ou por referência, dependendo da necessidade 
do programador. A letra C está incorreta, pois as estruturas podem ser passadas por valor ou por referência, 
não sendo necessário o uso de ponteiros. A letra D está incorreta, pois não é necessário o uso da palavra-
chave inline na declaração da função que recebe uma estrutura como parâmetro. A palavra-chave inline é 
usada para otimizar o desempenho de funções curtas, mas não está diretamente relacionada à passagem de 
estruturas como parâmetros. A letra E está incorreta, pois funções de qualquer tipo (não apenas do tipo 
void) podem receber estruturas como parâmetros. 
 
Gabarito: Letra B 
 
2. (CESPE – PG-DF – 2021) Tendo como referência o código, escrito em linguagem de programação ANSI C, 
julgue o item subsecutivo. 
 
#include <stdio.h> 
 
int main ( ) { 
 int vetor[10], i = 0, j = 0, auxiliar = 0; 
 
 for (i = 0; i < 10; i++) { 
 printf ("Digite um numero inteiro: "); 
 scanf ("%d", &auxiliar); 
 vetor[i] = auxiliar; 
 } 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
69
180
 for (i = 0; i < 10; i++) { 
 for (j = i+1; j < 10; j++) { 
 if ( vetor[i] > vetor [j]) { 
 auxiliar = vetor [i]; 
 vetor[i] = vetor[j]; 
 vetor[j] = auxiliar; 
 } 
 } 
 } 
 
for (i = 0; i < 10; i++) { 
 printf ("\n\n vetor[%d] = %d", i, vetor[i]); 
 } 
 
 system ("PAUSE"); 
 return 0; 
} 
 
Quando compilado e executado, o código solicita que o usuário digite dez números inteiros e, em 
seguida, ordena e mostra esses números na tela, em ordem crescente. 
 
Comentários: 
 
Este programa em C++ utiliza a biblioteca "vector" para criar um vetor de inteiros chamado "v". Em seguida, 
o programa utiliza um loop "for" para adicionar ao vetor os valores de i multiplicados por 2, ou seja, [0, 2, 4, 
6, 8, 10]. Depois disso, o programa remove os dois primeiros elementos do vetor usando o método "erase". 
Como resultado, o vetor agora tem os valores [4, 6, 8, 10]. Finalmente, o programa usa outro loop "for" para 
imprimir os elementos restantes do vetor. No entanto, há um erro na linha que imprime os elementos. Em 
vez de imprimir o valor do elemento, a variável "i" que representa um iterador é impressa. Para imprimir 
corretamente os valores, deve-se usar "*i" para acessar o valor do elemento no vetor. O código apresentado 
solicita ao usuário que digite 10 números inteiros, armazena esses valores em um vetor e, em seguida, usa o 
algoritmo de ordenação conhecido como "selection sort" para ordenar os números em ordem crescente. Por 
fim, o programa exibe os números ordenados na tela. Portanto, o item está correto. Quando compilado e 
executado, o código solicita que o usuário digite dez números inteiros e, em seguida, ordena e mostra esses 
números na tela, em ordem crescente. 
 
Gabarito: Correto 
 
3. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
Caso a linha for (i = 0; i < 10; i++) { fosse alterada para for (i = 0; i > 10; i++) { em suas três ocorrências, o 
código funcionaria invertendo a ordem dos números digitados e armazenados no vetor declarado no 
código. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
70
180
Pessoal, errada a questão! Na verdade, o código não funcionaria corretamente se a linha for (i = 0; i > 10; 
i++) { fosse alterada para as três ocorrências do loop for. Isso ocorre porque a condição do loop for é 
responsável por controlar a quantidade de iterações do loop, e a condição "i > 10" nunca seria satisfeita, pois 
a variável "i" é inicializada com o valor zero e incrementada a cada iteração. Portanto, o loop for nunca seria 
executado e nenhum número seria armazenado no vetor. Caso a intenção seja percorrer o vetor de forma 
invertida, a condição do loop for deveria ser alterada para "i >= 0" e o incremento da variável "i" deveria ser 
trocado para um decremento. 
 
Gabarito: Errado 
 
4. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
 
O comando printf ("\n\n vetor[%d] = %d", i, vetor[i]); continuaria funcionando corretamente mesmo que 
o comando #include não existisse no código. 
 
Comentários: 
 
Pessoal, questão errada! Na verdade, o comando printf não funcionaria corretamente se o comando #include 
correspondente à biblioteca stdio.h não existisse no código. Isso ocorre porque o comando printf faz parte 
da biblioteca padrão de entrada e saída de dados do C, e seu protótipo é definido na biblioteca stdio.h. Se a 
biblioteca não for incluída no código, o compilador não será capaz de reconhecer o comando printf, 
resultando em um erro de compilação. Portanto, é necessário que a biblioteca stdio.h seja incluída no código 
para que o comando printf e outros comandos relacionados à entrada e saída de dados possam ser utilizados 
corretamente. 
 
Gabarito: Errado 
 
5. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
 
O parâmetro %d, utilizado na linha scanf ("%d", &auxiliar);, permite a digitação apenasde números 
inteiros. 
 
Comentários: 
 
Perfeita questão pessoal! O parâmetro %d utilizado na linha scanf ("%d", &auxiliar); permite a leitura de 
números inteiros a partir do teclado. O %d é um especificador de formato utilizado pela função scanf para 
indicar que se espera a leitura de um número inteiro. Quando o usuário digita um número inteiro e pressiona 
a tecla Enter, o valor digitado é armazenado na variável auxiliar passada como argumento para a função 
scanf. Caso o usuário digite um valor que não seja um número inteiro, o comportamento da função scanf 
pode ser imprevisível, podendo ocorrer erros de leitura ou comportamentos inesperados. Portanto, é 
importante garantir que o valor digitado pelo usuário seja compatível com o formato especificado pelo 
parâmetro %d. 
 
Gabarito: Correto 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
71
180
6. (VUNESP – UNICAMP – 2022) Considere o seguinte programa na linguagem C++: 
 
#include <iostream> 
#include <vector> 
using namespace std; 
 int main() { 
 vector<int> v; 
 for (int i=0;i<=5;i++) { 
 v.push_back(i*2); 
 } 
 v.erase(v.begin()); 
 v.erase(v.begin()); 
 for (auto i=v.begin();i!=v.end();i++) { 
 cout << i << " "; 
 } 
 } 
 
A saída produzida por sua execução é: 
 
a) 4 6 8 
b) 6 4 2 
c) 2 4 6 8 
d) 4 6 8 10 
e) 8 6 4 2 
 
Comentários: 
 
A saída produzida pelo programa será: 2 4 6 8. Isso ocorre porque o valor i utilizado na linha v.push_back(i*2) 
é o valor de i após a execução do primeiro laço for, ou seja, 6. Portanto, os valores adicionados ao vetor v 
serão 12, que é o dobro de 6, e o laço for que imprime os elementos do vetor v irá imprimir na tela os valores 
4, 6 e 8, que são os elementos restantes após a remoção dos dois primeiros elementos. Assim, a opção 
correta é a letra d) 4 6 8 10. 
Gabarito: Letra D 
 
7. (VUNESP – UNICAMP – 2022) Na linguagem C++, estruturas (definidas pela palavra-chave struct) podem 
ser passadas como parâmetros em chamadas de funções. Nesse contexto, assinale a alternativa correta. 
Alternativas 
a) Por padrão, estruturas são passadas por referência. 
b) Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por 
valor requer que a estrutura inteira seja copiada. 
c) Estruturas só podem ser passadas como parâmetro por meio do uso de ponteiros. 
d) É necessário o uso da palavra-chave inline na declaração da função que recebe uma estrutura como 
parâmetro. 
e) Apenas funções do tipo void podem receber estruturas como parâmetros. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
72
180
A alternativa correta é a letra B: Passar estruturas por referência é mais eficiente que passá-las por valor, 
uma vez que a passagem por valor requer que a estrutura inteira seja copiada. Ao passar uma estrutura por 
valor em uma chamada de função, uma cópia completa da estrutura é criada, o que pode ser ineficiente em 
termos de uso de memória e processamento. Por isso, é comum passar estruturas por referência ou por 
ponteiro, que evitam a cópia desnecessária e podem melhorar a eficiência do programa. A opção A está 
incorreta, pois a passagem por referência é uma opção que deve ser explicitamente escolhida na definição 
da função ou na chamada da função, não sendo o padrão. A opção C está incorreta, pois as estruturas podem 
ser passadas tanto por valor quanto por referência (por meio de ponteiros ou referências). As opções D e E 
estão incorretas, pois a palavra-chave inline é usada para otimização do código em tempo de execução e não 
tem relação direta com a passagem de estruturas como parâmetros. Além disso, funções de qualquer tipo 
podem receber estruturas como parâmetros. 
Gabarito: Letra B 
 
8. (VUNESP – UNICAMP – 2022) Na linguagem C++, a linha de código 
 
 double * x,y; 
 
declara 
 
a) duas variáveis do tipo double. 
b) dois ponteiros para valores do tipo double. 
c) um ponteiro para um valor do tipo double e uma variável do tipo double. 
d) uma variável do tipo double e um ponteiro que aponta para ela. 
e) um ponteiro para uma função do tipo double que recebe dois parâmetros também do tipo double. 
 
Comentários: 
 
Em C++, o operador * é usado para declarar um ponteiro, que é uma variável que armazena o endereço de 
memória de outra variável. No código double * x, y;, a declaração double * x cria um ponteiro para um valor 
do tipo double chamado x. Já a declaração y cria uma variável do tipo double chamada y. Note que a 
declaração do ponteiro x só se aplica a ele e não à variável y. Ou seja, y não é um ponteiro e não armazena 
um endereço de memória, mas sim um valor do tipo double. Caso o objetivo fosse declarar dois ponteiros, a 
declaração correta seria double *x, *y;. Nesse caso, tanto x quanto y seriam ponteiros para valores do tipo 
double. Portanto, a alternativa correta é a letra C. 
Gabarito: Letra C 
 
9. (UFMT – Câmara de Cáceres - MT – 2022) A partir do trecho de código abaixo utilizando a linguagem de 
programação C, assinale a alternativa que apresenta a saída da execução do código. 
 
#include <stdio.h> 
int main() { 
 int i; 
 int vec[] = {1,2,3,4,5}; 
 *(vec + *vec) = vec[1]; 
 *(vec + vec[1]) = vec[3]; 
 *(vec + vec[2]) = *(vec + 0); 
 for(i = 0; i < 5; i++) 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
73
180
 printf("%d", vec[i]); 
 return 0; 
} 
 
a) 1 2 3 1 4 
b) 1 2 3 4 5 
c) 1 2 4 4 1 
d) 1 2 4 4 4 
 
Comentários: 
 
A resposta correta é a alternativa C. Durante a execução do código, a linha *(vec + *vec) = vec[1]; altera o 
valor do segundo elemento do vetor vec para 2 (valor armazenado na posição 1). Em seguida, a linha *(vec 
+ vec[1]) = vec[3]; altera o quarto elemento do vetor vec para 4 (valor armazenado na posição 3). Por fim, a 
linha *(vec + vec[2]) = *(vec + 0); altera o terceiro elemento do vetor vec para 1 (valor armazenado na posição 
0). Ao final, a função printf exibe os valores do vetor vec, que serão: 1 2 4 4 1. A alternativa C é a única que 
apresenta esses valores. 
Gabarito: Letra C 
 
10. (FADENOR – Prefeitura de Dores de Guanhães - MG – 2022) Analise o código a seguir, escrito na 
linguagem de programação C. 
 
#include <stdio.h> 
void sub (int *x, int y){ 
 *x = 3; 
 y = *x + 1; 
} 
int main() 
{ 
 int a, b, z; 
 a = 1; 
 b = 2; 
 sub(&a,b); 
 z=a+b; 
 printf("%d",z); 
 return 0; 
} 
 
O valor de Z, a ser mostrado na saída padrão, é 
 
a) 3. 
b) 4. 
c) 5. 
d) 7. 
e) 9. 
 
Comentários: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
74
180
 
O valor de Z será igual a 5. O programa define uma função chamada "sub" que recebe um ponteiro para 
inteiro (x) e um inteiro (y). Dentro da função, o valor apontado por x é alterado para 3 e o valor de y é 
atualizado para o valor apontado por x (que agora é 3) mais 1, mas essa atualização não afeta o valor de b 
na função main. Na função main, as variáveis a e b são definidas com valores 1 e 2, respectivamente. A função 
sub é chamada com o endereço de a e o valor de b. Isso significa que dentro da função sub, a referência 
apontada por x aponta para a variável a emmain, e qualquer alteração feita nessa referência afetará o valor 
de a em main. Após a chamada da função sub, o valor de z é a soma de a e b, que são 3 e 2, respectivamente. 
Portanto, o valor de z é 5 e a resposta correta é a alternativa c) 5. 
 
Gabarito: Letra C 
 
11. (IBFC – DPE-MT – 2022) Quanto às principais características das linguagens: Java, C e C++, analise as 
afirmativas abaixo e dê valores Verdadeiro (V) ou Falso (F). 
 
( ) A maioria dos códigos escritos em C pode ser compilada em C++. 
 
( ) A linguagem C é considerada como tipicamente orientada a objetos. 
 
( ) As IDE's Eclipse e NetBeans não comportam o desenvolvimento em Java. 
 
Assinale a alternativa que apresenta a sequência correta de cima para baixo: 
 
a) V - F - F 
b) V - V - F 
c) F - V - V 
d) F - F - V 
 
Comentários: 
 
A resposta correta é a alternativa A) V - F - F. (V) A maioria dos códigos escritos em C pode ser compilada em 
C++. C++ é uma extensão da linguagem C, então a maioria dos códigos escritos em C pode ser compilada em 
C++ sem problemas. No entanto, nem todos os recursos de C são suportados em C++, e há diferenças 
importantes na sintaxe e na semântica. (F) A linguagem C é considerada como tipicamente orientada a 
objetos. A linguagem C não é tipicamente orientada a objetos. C é uma linguagem procedural que não 
fornece suporte nativo para recursos de orientação a objetos, embora possa ser estendida por meio de 
bibliotecas externas, como o GObject. (F) As IDE's Eclipse e NetBeans não comportam o desenvolvimento 
em Java. Tanto o Eclipse quanto o NetBeans são IDEs populares que suportam o desenvolvimento em Java. 
Na verdade, eles são frequentemente usados para desenvolver aplicativos Java, além de outras linguagens. 
 
Gabarito: Letra A 
 
12. (FCC – TRT - 23ª REGIÃO (MT) – 2022) Considere o programa em C abaixo. 
 
#include <stdio.h> 
 int main() { 
 int y, *p, x; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
75
180
==30e709==
 y = 0; 
 p = &y; 
 x = *p; 
 x += 10; 
 ++ (*p); 
 --x; 
 (*p) += x; 
 printf ("y = %i\n", y); 
 return 0; 
} 
 
Ao ser compilado e executado em condições ideais, a saída do programa é: 
 
a) y = 9 
b) y = 0 
c) y = 10 
d) y = 1 
e) y = 11 
 
Comentários: 
 
A saída do programa será "y = 10". O programa começa definindo três variáveis: um inteiro y, um ponteiro 
para inteiro p e um inteiro x. y é inicializado como 0 e p é inicializado como o endereço de y. O programa 
então define x como o valor apontado por p, que é 0. x é então incrementado em 10, tornando-se 10. Em 
seguida, o valor apontado por p é incrementado em 1, tornando-se 1. Depois, x é decrementado em 1, 
tornando-se 9. Por fim, o valor apontado por p é incrementado em x, que é 9. Como resultado, o valor final 
de y é 10. Portanto, a resposta correta é a alternativa c) y = 10. 
Gabarito: Letra C 
 
13. (UFAM – UFAM – 2022) Considere o programa a seguir, elaborado na linguagem ANSI C: 
#include <stdio.h> 
 
int main() { 
 int i, j; 
 for (i = 0; i < 2; i++) { 
 for (j = 1; j < 3; j++) { 
 printf("Teste\n"); 
 } 
 } 
 return 0; 
} 
 
 
Assinale a opção CORRETA sobre o número de vezes que a palavra "Teste" será mostrada, ao 
executarmos o programa: 
 
a) 3 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
76
180
b) 4 
c) 5 
d) 6 
e) 7 
 
Comentários: 
 
O programa irá imprimir a palavra "Teste" quatro vezes. O primeiro loop for percorre duas vezes, enquanto 
o segundo loop for percorre duas vezes a cada iteração do primeiro loop. Portanto, a palavra "Teste" será 
impressa um total de quatro vezes. Portanto, a resposta correta é a alternativa b) 4. 
Gabarito: Letra B 
 
14. (UFAM – UFAM – 2022) Considere o programa a seguir, elaborado na linguagem ANSI C: 
 
#include <stdio.h> 
 
int* pa; 
int a; 
 
int main() { 
 a = 10; 
 pa = &a; 
 a = 8; 
 printf("%d", a); 
 printf(" %d", *pa); 
 return 0; 
} 
 
Assinale a alternativa CORRETA sobre a saída (output) obtida, ao se executar o programa: 
a) 8 8 
b) 10 8 
c) 8 10 
d) 10 10 
e) 9 10 
 
Comentários: 
 
O programa começa por incluir a biblioteca padrão de entrada e saída (stdio.h). Em seguida, define as 
variáveis pa e a. pa é um ponteiro para inteiro (int*) e a é uma variável inteira. Dentro da função main(), o 
programa atribui o valor 10 para a variável a. Em seguida, o endereço de a é atribuído a pa. Depois, o valor 
de a é alterado para 8. Finalmente, o programa imprime o valor de a e o valor apontado por pa (que também 
é 8), separados por um espaço. Assim, a saída do programa será: 8 8. Portanto, a alternativa correta é a letra 
"a". 
Gabarito: Letra A 
 
15. (UFMG – UFMG – 2021) Na linguagem C, foi declarada uma matriz: int matriz[5][6];. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
77
180
O código abaixo é utilizado para imprimir todos os elementos da matriz. 
 
for (int i = 0; i <= 4; i++) { 
 for (int j = 0; j <= 5; j++) { 
 printf("%d ", matriz[i][j]); 
 } 
} 
 
Qual deve ser os valores de a, b, c e d, respectivamente, para imprimir todos os elementos da matriz? 
 
a) 0; 4; 0; 5. 
b) 1; 4; 1; 5. 
c) 1; 5; 1; 6. 
d) 1; 6; 1; 5. 
 
Comentários: 
 
O código apresentado está correto em relação à sua sintaxe, mas falta contexto para saber se ele está 
adequado ao objetivo desejado. A estrutura for é utilizada para percorrer os elementos de uma matriz, onde 
a e b representam os limites das linhas a serem percorridas e c e d representam os limites das colunas a 
serem percorridas. Dentro do loop, o programa imprime o valor do elemento presente na posição i da linha 
e j da coluna da matriz. Como a matriz tem dimensões de 5 linhas e 6 colunas, os valores de índices válidos 
para a matriz serão de 0 a 4 para as linhas e de 0 a 5 para as colunas. Portanto, para imprimir todos os 
elementos da matriz, podemos utilizar os valores: a = 0 (primeira linha), b = 4 (última linha), c = 0 (primeira 
coluna), d = 5 (última coluna) 
 
Gabarito: Letra A 
 
16. (UFMG – UFMG – 2021) Considerando o código escrito na linguagem C: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() { 
 int a; 
 int b = 4; 
 a = b++; 
 printf("a=%d e b=%d\n", a, b); 
 return 0; 
} 
 
Qual é o resultado da execução do código? 
 
a) a=4 e b=4 
b) a=4 e b=5 
c) a=5 e b=4 
d) a=5 e b=5 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
78
180
 
Comentários: 
 
O resultado da execução do código é a=4 e b=5. Isso acontece porque a expressão "b++" primeiro atribui o 
valor atual de "b" para "a" (que fica com valor 4), e depois incrementa o valor de "b" para 5. Então, ao 
imprimir os valores de "a" e "b" no printf, teremos a=4 e b=5. 
Gabarito: Letra B 
 
17. (UFMG – UFMG – 2021) Considerando o código escrito na linguagem C: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
void ops(int *a, int b){ 
 *a = 4; 
 b = *a + 2; 
} 
 
int main() { 
 int x, y, total; 
 x = 1; 
 y = 2; 
 ops(&x,y); 
 total = x + y; 
 printf("%d",total); 
 return 0; 
} 
 
 
Qual é o valor da variável total que será impresso na saída padrão? 
 
a) 4 
b) 6 
c) 7 
d) 10 
 
Comentários: 
 
O valor da variável xé alterado para 4 pela função ops() e o valor da variável y permanece 2. O programa 
começa com a declaração da função ops, que recebe um ponteiro para inteiro a e um inteiro b. Dentro da 
função, o valor apontado por a é alterado para 4, e o valor de b é modificado para a soma de *a (valor 
apontado por a) mais 2. Como a função ops foi chamada com x passado por referência, a variável x é alterada 
para 4 e y permanece com o valor 2. Na sequência, o valor de total é a soma de x com y, que resulta em 6. 
Esse valor é impresso na tela com o comando printf. Portanto, a alternativa correta é a letra B: 6. 
 
Gabarito: Letra B 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
79
180
18. (CETAP – SEPLAD - PA – 2021) Considere o seguinte programa exemplo escrito em linguagem C e marque 
a alternativa correta. 
 
#include <stdio.h> 
 
int soma(int n) { 
 if(n == 1) 
 return 1; 
 else 
 return (n + soma(n-1)); 
} 
 
int main() { 
 int n; 
 printf("Digite um inteiro positivo: "); 
 scanf("%d", &n); 
 printf("Soma: %d\n", soma(n)); 
 return 0; 
} 
 
(*) fonte do programa retirado de https:/Awww.cprogressivo.net/ acessado em 09/09/2021. 
 
a) O programa exemplo mostra o uso do método de iteração. 
b) O programa exemplo mostra o uso do método de ordenação. 
c)O programa exemplo mostra o uso do método de passagem de parâmetro. 
d) O programa exemplo mostra o uso do método de recursão. 
 
Comentários: 
 
Gabarito: d) O programa exemplo mostra o uso do método de recursão. O programa calcula a soma dos 
números inteiros de 1 até um número n, utilizando a técnica de recursão. A função soma() é chamada 
recursivamente até que o valor de n seja igual a 1, quando a função retorna 1. Em seguida, as chamadas 
recursivas da função são finalizadas, e os valores de n são somados em cada retorno da função, resultando 
na soma total dos números inteiros de 1 até n. 
Gabarito: Letra D 
 
19. (Instituto UniFil – Prefeitura de Marechal Cândido Rondon - PR – 2021) Linguagem compilada é uma 
linguagem de programação em que o código fonte, nessa linguagem, é executado diretamente pelo 
sistema operacional ou pelo processador, após ser traduzido por meio de um processo chamado 
compilação, usando um programa de computador chamado compilador, para uma linguagem de baixo 
nível, como linguagem de montagem ou código de máquina. Assinale a alternativa que representa 
somente linguagens que são compiladas. 
 
a) Cobol, PHP, C e Python 
b) Cobol, C, Delphi e PHP 
c) Cobol, C, Delphi e C++ 
d) Delphi, C, PHP e Python 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
80
180
 
Comentários: 
 
A) Cobol, PHP, C e Python: Cobol: é uma linguagem compilada, utilizada principalmente em sistemas 
corporativos e financeiros. PHP: é uma linguagem interpretada, mas é possível compilar o código PHP 
utilizando o Zend Engine, o que faz com que o código seja executado mais rapidamente. C: é uma linguagem 
compilada, amplamente utilizada em sistemas operacionais, drivers de dispositivos, jogos, entre outros. 
Python: é uma linguagem interpretada, mas é possível utilizar ferramentas como o PyInstaller e o PyOxidizer 
para compilar o código Python em um executável. B) Cobol, C, Delphi e PHP: Cobol e C: já explicados 
anteriormente. Delphi: é uma linguagem compilada, utilizada para desenvolvimento de aplicativos para 
desktop, servidores e aplicações móveis. PHP: já explicado anteriormente. C) Cobol, C, Delphi e C++: Cobol, 
C e Delphi: já explicados anteriormente. C++: é uma linguagem compilada, derivada do C e utilizada 
principalmente no desenvolvimento de jogos, sistemas embarcados e software de alta performance. D) 
Delphi, C, PHP e Python: Delphi, C e PHP: já explicados anteriormente. Python: já explicado anteriormente. 
O gabarito é a letra C, pois todas as linguagens mencionadas são linguagens compiladas, ou seja, o código 
fonte é traduzido em código de máquina antes da execução. COBOL, C, Delphi e C++ são exemplos clássicos 
de linguagens compiladas, onde o compilador é responsável por gerar o arquivo executável diretamente a 
partir do código fonte. Por outro lado, as linguagens interpretadas, como Python e PHP, não precisam de um 
processo de compilação antes da execução do código, pois o interpretador pode executar diretamente o 
código fonte linha por linha. Portanto, a alternativa A está incorreta por incluir linguagens interpretadas, 
enquanto as alternativas B e D estão incorretas por não incluírem a linguagem C++, que também é uma 
linguagem compilada. 
 
Gabarito: Letra C 
 
20. (IDIB – CRECI-PE - 7ª Região – 2021) Qual será a saída do seguinte código C? 
 
#include <stdio.h> 
int main() { 
 int ary[4] = {1, 2, 3, 4}; 
 printf("%d\n", *ary); 
 return 0; 
} 
 
a) 1. 
b) Erro de tempo de compilação (run time error). 
c) Algum valor de lixo. 
d) Variável indefinida. 
 
Comentários: 
 
O código declara um array de inteiros com 4 elementos e inicializa com os valores 1, 2, 3 e 4. Em seguida, é 
impresso na saída padrão o valor do primeiro elemento do array utilizando o operador de desreferência 
(*ary). Como o primeiro elemento do array é 1, a resposta correta é a alternativa A: "1". Não há erros de 
compilação ou de tempo de execução no código. 
 
Gabarito: Letra A 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
81
180
 
21. (UFMT – UFMT – 2021) A linguagem de programação C é de propósito geral, sendo caracterizada como 
procedural e imperativa, desenvolvida em 1972 por Dennis M. Ritchie, baseando-se na sua experiência 
com o sistema operacional UNIX. Sua versatilidade e portabilidade lhe garantiram longa vida, sendo 
utilizada hoje também em programação de sistemas embarcados. A linguagem C foi formalizada com o 
ISO/IEC 9899:1990. Analise o código do programa a seguir conforme as definições da linguagem C. 
 
#include <stdio.h> 
 
int um_de_dois(int num1, int num2); 
 
int main() { 
 int a = 100; // definição de variáveis locais 
 int b = 20; 
 int ret_um; 
 ret_um = um_de_dois(a, b); // chamada da função 
 printf("O valor é: %d\n", ret_um); 
 return 0; 
} 
 
int um_de_dois(int num1, int num2) { 
 int result; // declaração de variáveis locais 
 if (num1 > num2) 
 result = num1; 
 else 
 result = num2; 
 return result; 
} 
 
Sobre esse código, marque V para as afirmativas verdadeiras e F para as falsas. 
( ) A execução do programa produz como saída: O valor é: 20. 
( ) A formatação da saída poderia ser feita sem erro com o comando: printf( "O valor é: %f\n", ret_um ); 
( ) A passagem de parâmetros para a função é por valor, pois a função um_de_dois(int num1, int num2) 
não altera o valor da variáveis int a ou int b. 
( ) Os parâmetros formais são os argumentos da função um_de_dois(int num1, int num2), declarados 
como variáveis que aceitam os argumentos da chamada da função um_de_dois(a, b). 
 
Assinale a sequência correta. 
 
a) F, V, F, V 
b) V, V, F, F 
c) V, F, V, F 
d) F, F, V, V 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
82
180
A primeira afirmativa é falsa, pois a execução do programa produz como saída: O valor é: 100. A segunda 
afirmativa é falsa, poiso tipo de dado da variável ret_um é int e não float. A terceira afirmativa é verdadeira, 
pois a passagem de parâmetros para a função em C é por valor, ou seja, a função recebe cópias dos valores 
das variáveis passadas como argumentos. A quarta afirmativa é verdadeira, pois os parâmetros formais são 
os argumentos da função, e na chamada da função, os valores das variáveis a e b são passados como 
argumentos. 
Gabarito: Letra D 
 
22. (CEPUERJ – UERJ – 2021) Um tipo de dados define uma coleção de valores de dados e um conjunto de 
operações pré-definidas sobre ele. O sistema de tipos de uma linguagem de programação define como 
um tipo é associado com cada expressão na linguagem e inclui suas regras para equivalência e 
compatibilidade de tipos. Entender seu sistema de tipos é uma das partes mais importantes para 
entender a semântica de uma linguagem de programação. De acordo com essa afirmação e com os 
conceitos da linguagem de programação Java, é correto afirmar que: 
 
a) o tipo de dado matriz é um agregado homogêneo de elementos de dados no qual um elemento 
individual é identificado por sua posição na agregação. Na linguagem Java, os elementos de uma matriz 
não precisam ser do mesmo tipo 
b) a enumeração é um tipo de dado ordinal definido pelo usuário e fornece uma maneira de declarar e 
agrupar coleções de constantes nomeadas 
c) um ponteiro em Java é um tipo de dado em que as variáveis têm uma faixa de valores que consistem 
em endereços de memória 
d) a herança múltipla na linguagem Java segue o mesmo formato e comportamento da linguagem C++ 
 
Comentários: 
 
a) Essa afirmação não é correta para a linguagem de programação Java. Em Java, uma matriz é um tipo de 
dado homogêneo que contém elementos do mesmo tipo. Além disso, a declaração de uma matriz em Java 
requer que seu tamanho seja especificado no momento da declaração. b) Essa afirmação é correta. A 
enumeração em Java é um tipo de dado ordinal que permite declarar e agrupar constantes nomeadas. Por 
exemplo, podemos definir uma enumeração "DiasDaSemana" com as constantes "SEGUNDA", "TERÇA", 
"QUARTA", "QUINTA", "SEXTA", "SÁBADO" e "DOMINGO". c) Essa afirmação não é correta para a linguagem 
de programação Java. Em Java, não existem ponteiros como na linguagem C ou C++. Em vez disso, as 
referências de objetos são usadas para se referir a objetos alocados dinamicamente na memória. Essas 
referências não contêm endereços de memória diretos, mas sim apontam para objetos alocados na 
memória. d) Essa afirmação não é correta. A linguagem Java não suporta herança múltipla direta de classes, 
embora possa ser simulada usando interfaces. Já na linguagem C++, a herança múltipla é suportada 
diretamente. Portanto, a herança múltipla na linguagem Java é diferente do formato e comportamento da 
linguagem C++. 
 
Gabarito: Letra B 
 
23. (INSTITUTO AOCP – ITEP - RN – 2021) Analise o código C++ a seguir: 
 
#include <iostream> 
using namespace std; 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
83
180
void meuNome(string nome, int idade) { 
cout << "Seu nome é " << nome << " e sua idade é " << idade << endl; 
} 
 
int main() { 
string nome; 
int idade; 
cout << "Digite seu nome: "; 
cin >> nome; 
cout << "Digite sua idade: "; 
cin >> idade; 
meuNome(nome, idade); 
return 0; 
} 
 
Para que a chamada da função meuNome, ocorra livre de erros, assinale a alternativa correta em relação 
à escrita dessa função. 
 
a) void meuNome(string Nome, int Idade) { cout << "Meu nome é "<< Nome << ". Tenho " << Idade << " 
anos.\n"; } 
b) meuNome(string nome, int idade) { cout << "Meu nome é "<< nome << ". Tenho " << idade << " 
anos.\n"; } 
c) void meuNome(nome, idade) { cout << "Meu nome é "<< nome << ". Tenho " << idade << " anos.\n"; } 
d) meuNome() { cout << "Meu nome é "<< nome << ". Tenho " << idade << " anos.\n"; } 
e) void meuNome(nome, idade) { cout << "Meu nome é %s.", nome; cout << "Tenho %d anos.", idade; } 
 
Comentários: 
 
A função meuNome deve receber dois argumentos, uma string para o nome e um inteiro para a idade, 
conforme definido na declaração da função. Na alternativa a), os nomes dos parâmetros da função estão 
corretos e a mensagem de saída está de acordo com a esperada no código original. Nas demais alternativas, 
há erros de sintaxe ou semântica que impedem a compilação ou o correto funcionamento do programa. 
 
Gabarito: Letra A 
 
24. (INSTITUTO AOCP – ITEP - RN – 2021) Em linguagens de programação, os tipos de dados podem ser 
classificados como elementares ou estruturados. Em qual das alternativas a seguir há exemplos somente 
de um mesmo tipo de dado (elementar ou estruturado) reconhecido pela linguagem C++? 
 
a) Struct e array. 
b) Integer e class. 
c) Float e class. 
d) Char e union. 
e) Enum e struct. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
84
180
Uma struct é um tipo de dado definido pelo usuário que permite agrupar diferentes variáveis sob um único 
nome. É uma coleção de variáveis de tipos diferentes, que são acessadas por meio de um identificador 
comum. Um array é uma coleção de elementos de um mesmo tipo de dados, que é armazenada em uma 
sequência contígua de memória. Cada elemento pode ser acessado por meio de um índice. Integer é um tipo 
de dado primitivo que armazena valores numéricos inteiros. Em C++, ele é representado pelo tipo "int". Class 
é um tipo de dado definido pelo usuário que permite criar uma abstração de dados. É uma estrutura que 
encapsula dados e comportamentos relacionados a esses dados em uma única entidade. Uma classe pode 
conter variáveis, funções e métodos. Float é um tipo de dado primitivo que armazena valores numéricos em 
ponto flutuante. Em C++, ele é representado pelo tipo "float". Char é um tipo de dado primitivo que 
armazena um único caractere. Em C++, ele é representado pelo tipo "char". Union é um tipo de dado definido 
pelo usuário que permite que diferentes tipos de dados compartilhem o mesmo espaço de memória. A ideia 
é que apenas um dos tipos esteja ativo em um determinado momento e o acesso aos dados da union deve 
ser feito de forma cuidadosa para evitar comportamentos inesperados. Por fim, Enum é um tipo de dado 
definido pelo usuário que permite definir um conjunto de constantes nomeadas. As constantes são 
atribuídas a valores inteiros sequenciais, a partir de um valor inicial especificado. A opção que apresenta 
exemplos somente de um mesmo tipo de dado (elementar ou estruturado) reconhecido pela linguagem C++ 
é a alternativa A) Struct e array. 
 
 
Gabarito: Letra A 
 
25. (INSTITUTO AOCP – ITEP - RN – 2021) Em relação às características da linguagem C, assinale a alternativa 
correta. 
 
a) É uma linguagem interpretada. 
b) Não possui tratamento de exceções. 
c) Possui 64 palavras reservadas. 
d) Suporta orientação a objeto. 
e) Os tipos básicos de variáveis para manipulação de caracteres são o char e string. 
 
Comentários: 
 
Vamos analisar cada alternativa: a) É uma linguagem interpretada. Esta afirmação é incorreta. C é uma 
linguagem compilada, o que significa que o código-fonte é transformado em código objeto por meio de um 
compilador antes de ser executado. b) Não possui tratamento de exceções. Esta afirmação é verdadeira. A 
linguagem C não possui mecanismos de tratamento de exceções nativamente, o que pode tornar o código 
propenso a erros inesperados em tempo de execução. c) Possui 64 palavras reservadas. Esta afirmação é 
incorreta. A linguagem C possui um número limitado de palavras-chave reservadas, que podem variar de 
acordo com a implementação do compilador. Por exemplo, o padrãoC99 especifica apenas 32 palavras-
chave reservadas. d) Suporta orientação a objeto. Esta afirmação é parcialmente verdadeira. Embora a 
linguagem C não tenha recursos de orientação a objeto integrados, é possível implementar conceitos de 
programação orientada a objetos em C usando técnicas como estruturas e ponteiros de função. e) Os tipos 
básicos de variáveis para manipulação de caracteres são o char e string. Esta afirmação é incorreta. O tipo 
básico para manipulação de caracteres em C é o char, enquanto a string é uma sequência de caracteres 
terminada por um caractere nulo ('\0') e é implementada como um array de chars. 
 
Gabarito: Letra B 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
85
180
 
26. (FADESP – Câmara de Marabá - PA – 2021) Considerando o operador de pós-incremento, utilizado na 
linguagem C, o resultado da execução do código é: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() { 
 int y, x = 10; 
 y = x++; 
 printf("x = %d\n", x); 
 printf("y = %d\n", y); 
 system("pause"); 
 return 0; 
} 
 
a) x = 10 e y = 10. 
b) x = 11 e y = 11. 
c) x = 10 e y = 11. 
d) x = 11 e y = 10. 
e) x = 11 e y = 0. 
 
Comentários: 
 
O operador de pós-incremento (++) incrementa o valor de uma variável após o uso dessa variável em uma 
expressão. No código fornecido, o valor de x é atribuído a y antes de ser incrementado.Assim, a expressão y 
= x++ é avaliada da seguinte maneira: A variável y recebe o valor de x, que é 10. O operador de pós-
incremento é aplicado em x, fazendo com que o seu valor seja incrementado em 1, passando a ser 11. 
Portanto, no final da execução, o valor de x é 11 e o valor de y é 10. A alternativa correta é a letra d). 
 
Gabarito: Letra D 
 
27. (IBFC – IBGE – 2021) Quanto às linguagens de programação, assinale a alternativa que esteja 
tecnicamente incorreta. 
 
a) Java é uma das principais representantes das linguagens orientadas a objetos 
b) JavaScript, é uma sub-línguagem do Java, feita para o desenvolvimento de aplicações para Android 
c) Grande parte dos sistemas operacionais existentes no mercado foram escritos em C 
d) Assembly é uma linguagem de programação de baixo nível, também definida, muitas vezes, como 
linguagem de montagem 
e) A linguagem de programação C# foi desenvolvida pela Microsoft 
 
Comentários: 
 
A alternativa INCORRETA é a letra B. JavaScript é uma linguagem de programação que permite a você 
implementar itens complexos em páginas web — toda vez que uma página da web faz mais do que 
simplesmente mostrar a você informação estática — mostrando conteúdo que se atualiza em um intervalo 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
86
180
de tempo, mapas interativos ou gráficos 2D/3D animados, etc. — você pode apostar que o JavaScript 
provavelmente está envolvido. Ademais, vejamos a alternativa C que trata sobre a linguagem C. A alternativa 
C está correta, já que grande parte dos sistemas operacionais foram escritos em C. Na verdade, muitos dos 
principais sistemas operacionais do mercado, como o Unix, o Linux e o Windows, foram criados com o uso 
da linguagem C. A linguagem C é muito popular para programação de sistemas, já que permite um controle 
mais preciso sobre o hardware do computador e é altamente portátil, permitindo que o mesmo código seja 
executado em diferentes sistemas operacionais. Além disso, a linguagem C é bastante eficiente e oferece 
recursos para gerenciamento de memória e acesso a dispositivos de hardware, o que a torna uma escolha 
popular para o desenvolvimento de drivers e outros softwares de baixo nível. 
 
Gabarito: Letra B 
 
28. (FAFIPA – Prefeitura de Arapongas - PR – 2020) A linguagem de programação C é uma linguagem 
compilada de propósito geral, estruturada, imperativa e procedural. Esta é uma das linguagens de 
programação mais populares e tem influenciado muitas outras linguagens de programação, como por 
exemplo, a linguagem Java. Observe a figura, onde é apresentado um código escrito em C: 
 
#include <stdio.h> 
 
int main() 
{ 
 int i = 3; 
 printf("%d", ++i); 
 return 0; 
} 
 
Após executar o código da figura no Compilador C, o que será apresentado no console? 
 
a) 4. 
b) 3. 
c) 2. 
d) 1. 
e) 0. 
 
Comentários: 
 
O código apresentado é um programa em C que imprime o valor de uma variável "i" na tela, utilizando a 
função "printf" da biblioteca padrão "stdio.h". Inicialmente, é declarada a variável "i" como um inteiro e 
atribuído o valor 3 a ela. Em seguida, a expressão "++i" é utilizada como argumento da função "printf". A 
expressão "++i" é um operador de pré-incremento, que incrementa o valor da variável "i" em 1 e retorna o 
novo valor. Portanto, quando a função "printf" é executada, o valor impresso na tela será 4, que é o valor 
resultante da operação "++i" (3+1). Ao executar o código apresentado, será exibido o valor 4 no console, pois 
o operador de pré-incremento (++i) incrementa o valor da variável i em 1 antes de imprimi-la na tela. Sendo 
assim, o valor de i será 4 no momento da impressão. 
Gabarito: Letra A 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
87
180
29. (FAPEC – UFMS – 2020) Considere o código a seguir, utilizando a linguagem de programação C. Assinale 
a alternativa correta. 
 
#include <stdio.h> 
 
int main() { 
 int x = 1, y, z; 
 y = ++x; 
 z = y++; 
 y = 2; 
 printf("%%%d, %d, %d%%", x, y, z); 
 return 0; 
} 
 
a) Será impresso: %1, 2, 3%. 
b) Será impresso: 2, 2, 3. 
c) Será impresso: %2, 2, 2%. 
d) Será impresso: 1, 2, 3. 
e) Ocorrerá o seguinte erro: incompatible type for argument 1 of ‘printf’. 
 
Comentários: 
 
O código declara três variáveis inteiras: x, y e z, inicializando apenas x com o valor 1. Em seguida, a variável 
y recebe o valor de x após ser incrementado em 1 (devido ao operador de pré-incremento ++x). Depois, a 
variável z recebe o valor de y antes de ser incrementado (devido ao operador de pós-incremento y++). A 
variável y recebe o valor 2. Em seguida, a variável y é atribuída com o valor 2. Por fim, a função printf() é 
chamada para imprimir o valor de x, y e z, respectivamente, em um formato específico. Como resultado, será 
impresso "%2, 2, 2%" no console. 
 
Gabarito: Letra C 
 
30. (FUCAP – Câmara da Estância Balneária de Praia Grande - SP – 2019) Assinale a única alternativa que 
indica corretamente a principal linguagem de programação usada para escrever o código-fonte das várias 
versões do Windows: 
 
a) Java; 
b) Javascript; 
c) PHP; 
d) C. 
 
Comentários: 
 
A principal linguagem de programação utilizada para escrever o código-fonte do sistema operacional 
Windows é a linguagem de programação C. O Windows é escrito em grande parte em C, embora também 
seja utilizada a linguagem Assembly para algumas partes críticas do sistema. 
 
Gabarito: Letra D 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
88
180
 
31. (UFAM – UFAM – 2019) Considere o programa na linguagem C: 
 
#include <stdio.h> 
 
int main() { 
 int array[10] = {1, -2, 3, -4}; 
 int a, loop; 
 a = 0; 
 for (loop = 1; loop >= 0; loop--) { 
 a = a + array[loop]; 
 } 
 printf(" %d", a); 
 return 0; 
} 
 
Ao executarmos o programa, ovalor da saída será: 
 
a) −1 
b) 1 
c) −2 
d) 2 
e) 3 
 
Comentários: 
 
O programa declara um array de inteiros chamado array com tamanho 10, mas apenas os quatro primeiros 
elementos são inicializados. Em seguida, ele inicializa a variável a como zero e entra em um loop for que 
começa com a variável loop igual a 1 e decrementa até 0. Dentro do loop, a variável a é atualizada 
adicionando o valor do elemento array[loop]. Na primeira iteração do loop, loop é 1 e array[1] é -2, então a 
é atualizada para -2. Na segunda iteração do loop, loop é 0 e array[0] é 1, então a é atualizada para -1. Por 
fim, o programa imprime o valor de a, que é -1. Portanto, a resposta correta é a letra A) −1. 
 
Gabarito: Letra A 
 
32. (UFAM – UFAM – 2019) Considere o programa na linguagem C: 
 
#include <stdio.h> 
 int main(){ 
 int a, b, c; 
 printf("Digite dois números\n"); 
 scanf("%d%d", &a, &b); 
 c = a; 
 a = b; 
 b = a; 
 printf("%d %d\n", a, b); 
 return 0; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
89
180
 } 
 
Executando e digitando como entrada os números 12 e 14, a saída será: 
 
a) 12 14 
b) 12 12 
c) 14 14 
d) 14 12 
e) 26 
 
Comentários: 
 
A variável b é atribuída para a, e em seguida a variável a é atribuída novamente para b, o que acaba deixando 
ambas com o mesmo valor original. Portanto, a saída será 14 14, correspondente às variáveis a e b, 
respectivamente. A alternativa correta é a letra c). 
 
Gabarito: Letra C 
 
33. (FURB – Prefeitura de Porto Belo - SC – 2019) Leve em consideração o código abaixo, em linguagem C: 
 
#include <stdio.h> 
 
int a(int b) { 
 if (b <= 1) { 
 return 1; 
 } 
 return b * a(b - 1) - 1; 
} 
 
void main() { 
 int b = a(5), d = 0, c = 1, e = 43; 
 while (1) { 
 d = 1; 
 c += 2; 
 b -= 7; 
 if ((c + e + d + b) <= 44) { 
 printf("%d\n", c); 
 break; 
 } 
 d = a(d); 
 e -= c; 
 } 
 printf("%d\n", e); 
 printf("%d", b); 
} 
 
Os valores impressos na tela serão, respectivamente: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
90
180
 
a) 9, 28, 6. 
b) 3, 43, 27. 
c) 19, -37, 27. 
d) 11, 19, -1. 
e) 3, 43, 0. 
 
Comentários: 
 
O programa irá imprimir os valores 3, 43 e 27. A função "a(int b)" é uma função recursiva que calcula o 
fatorial de um número, mas com a particularidade de subtrair 1 do resultado final. Neste caso, a chamada 
"a(5)" retorna o valor 119, que é atribuído à variável "b". Dentro do laço "while", a variável "c" é 
incrementada em 2 a cada iteração, a variável "b" é decrementada em 7, e a variável "d" é atribuída o valor 
1. O resultado da expressão "(c + e + d + b) <= 44" é verdadeiro quando "c" vale 3, "e" vale 43, "d" vale 1 e 
"b" vale 27, o que faz o programa entrar no "if" e imprimir o valor de "c" (3) e sair do laço com "break". 
Depois disso, o programa imprime o valor de "e" (43) e o valor de "b" (que agora vale 27). 
 
Gabarito: Letra B 
 
34. (IBADE – Prefeitura de Vilhena - RO – 2019) Dado o código abaixo, escrito em linguagem de programação 
C, o que seria impresso na tela se fosse compilado e executado? 
 
int main(){ 
 int i, j, k=1, mat[4][4]; 
 for(i=0; i<4; i++) 
 for(j=0; j<4; j++){ 
 mat[i][j]=k; 
 k++; 
 } 
 
 for(i=0; i<4; i++) 
 for(j=2; j<4; j++) 
 if(i%j == 0) 
 printf("%d; ",mat[j][i]); 
 return 0; 
} 
 
a) 1; 3; 5; 7; 11 
b) 3; 6; 9; 12; 15 
c) 9; 13; 11; 16 
d) 1; 5; 10; 15 
e) 10 
 
Comentários: 
 
O código acima apresenta um programa em linguagem de programação C. O programa cria uma matriz de 
inteiros de tamanho 4x4 e preenche cada elemento com um valor sequencial a partir de 1. Em seguida, é 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
91
180
feita uma verificação em um laço de repetição em que, se a variável i for divisível por j, onde j é um valor 
entre 2 e 3, é impresso o valor do elemento da matriz correspondente à linha j e coluna i. Como i varia de 0 
a 3 e só é impresso o valor do elemento da matriz quando i é divisível por j (sendo j um número primo), 
apenas alguns elementos da matriz serão impressos. Neste caso, serão impressos os valores 9, 13, 11 e 16. 
Portanto, a resposta correta é a alternativa c) 9; 13; 11; 16. 
Gabarito: Letra C 
 
35. (IDECAN – UNIVASF – 2019) Dado o seguinte código fonte na linguagem C: 
 
#include <stdio.h> 
#include <unistd.h> 
 
int main() { 
 int i; 
 for (i = 0; i < 4; i++) { 
 if (i % 2 == 0) { 
 fork(); 
 } 
 } 
 return 0; 
} 
Assinale a alternativa que indica corretamente, incluindo o processo pai inicial, quantos processos são 
criados pelo programa mostrado no código após compilação com o compilador GCC e execução na linha 
de comando. 
 
a) 5 
b) 4 
c) 3 
d) 2 
e )1 
 
 
Comentários: 
 
O código em questão cria processos filhos a partir de um processo pai utilizando a função fork(), que cria um 
novo processo. No loop for, a cada iteração, é verificado se i é um número par, caso seja, é chamada a função 
fork(), criando um novo processo filho que passa a ser executado em paralelo com o processo pai. O número 
de processos criados depende do número de iterações do loop e das condições definidas dentro do mesmo. 
Neste caso, são criados 4 processos (incluindo o processo pai inicial), já que o loop executa 4 vezes e a 
condição para criar um processo é que o valor de i seja par. 
 
Caso queira uma explicação mais detalhada, siga em frente, se já entendeu de forma suficiente, vá para a 
próxima questão. Quer entender mais? Então vamos lá: Ao iniciar a execução do programa, a variável i é 
inicializada com 0 e, em seguida, o loop é executado quatro vezes. Na primeira iteração, o valor de i é 0 e o 
resultado da expressão i % 2 é 0, portanto, o processo pai cria um novo processo filho usando a função fork(). 
Esse novo processo filho também continua a executar o mesmo loop for. Na segunda iteração, o valor de i é 
1 e o resultado de i % 2 é 1, então o processo pai não cria um novo processo filho. No entanto, o processo 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
92
180
filho criado na primeira iteração continua a executar o mesmo loop for. Na terceira iteração, o valor de i é 2 
e o resultado de i % 2 é 0, portanto, tanto o processo pai quanto o processo filho criado na primeira iteração 
criam um novo processo filho cada usando a função fork(). Ambos os processos filhos criados também 
executam o mesmo loop for. Na última iteração, o valor de i é 3 e o resultado de i % 2 é 1, portanto, o 
processo pai e o processo filho criado na segunda iteração não criam um novo processo filho. O primeiro 
processo filho criado na primeira iteração cria um novo processo filho e continua a executar o loop for, 
enquanto os outros dois processos filhos criados na terceira iteração executam o loop for. Assim, no final, 
serão criados 4 processos filhos em total, cada um executando o loop for a partir do ponto em que foi criado. 
 
Gabarito: Letra B 
 
36. (FCC – TRF - 3ª REGIÃO – 2019) Em C++, a chamada de uma função provoca o desvio do controle de 
execução para o iníciodo código da função. Quando do seu término, o controle de execução volta para 
a instrução seguinte à sua chamada. Funções poupam espaço de memória, mas requerem mais tempo 
de execução. Se houver uma função muito pequena em relação à quantidade de instruções, em seu lugar 
utiliza-se 
 
a) DO WHILE. 
b) INCLUDE. 
c) PERFORM 
d) INLINE. 
e) DO UNTIL. 
 
 
Comentários: 
 
Em C++, se uma função for muito pequena em relação à quantidade de instruções, pode-se utilizar a diretiva 
inline para indicar ao compilador que o código da função deve ser "inserido" diretamente no local em que a 
função é chamada, evitando assim a sobrecarga de chamada de função e aumentando o desempenho do 
programa. A opção correta é a letra D. 
 
Gabarito: Letra D 
 
37. (COMPERVE – UFRN – 2019) O chefe do departamento de TI da Security10 enviou para João, por e-mail, 
o programa simples em linguagem C, mostrado abaixo, com intuito de aferir os conhecimentos do novo 
contratado sobre segurança de software. 
 
L1. void LerParametros (char *arg); 
L2. void main (int argc, char *argv[]) { 
L3. if (arg > 1){ 
L4. printf ("Parametros informados: %s\n", argv[1]); 
L5. LerParametros (argv[1]); 
L6. } 
L7. } 
L8. void LerParametros (char *arg) { 
L9. char buffer[10]; 
10. strcpy (buffer, arg); 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
93
180
L11. printf (buffer); 
L12. } 
 
 
Junto ao código, estava a mensagem: “João, por favor, verifique esse código. Sei que estamos fazendo 
algo errado e, com isso, expondo uma vulnerabilidade de segurança comum em programação, mas não 
consigo perceber qual. Falamos mais sobre isso na segunda”. João, ao analisar o código enviado, concluiu 
que esse apresenta como vulnerabilidade 
 
a) uma Falha de Segmentação (do inglês, Segmentation Fault) na linha L5. 
b) uma Falha de Segmentação (do inglês, Segmentation Fault) na linha L4. 
c) um Estouro de buffer (do inglês, Buffer Overflow) na linha L9. 
d) um Estouro de buffer (do inglês, Buffer Overflow) na linha L10. 
 
Comentários: 
 
A vulnerabilidade presente no código é o Estouro de buffer (Buffer Overflow) na linha L10. Isso ocorre porque 
a função strcpy() copia a string de argumento para o buffer sem verificar se a string cabe no buffer. Se a 
string de argumento for maior que o buffer (no caso, 10 caracteres), haverá um estouro de buffer e o 
comportamento do programa se torna indefinido, podendo levar a erros de segmentação, execução de 
código malicioso e outros problemas de segurança. Para corrigir essa vulnerabilidade, é necessário verificar 
o tamanho da string de argumento antes de copiá-la para o buffer. Uma solução seria usar a função strncpy(), 
que permite definir o tamanho máximo de cópia. 
Gabarito: Letra D 
 
38. (IF-MT – IF-MT – 2019) Analise o trecho de código escrito na linguagem C apresentado a seguir: 
 
#include <stdio.h> 
 
int main(void) { 
 int c, *x1, *x2; 
 x1 = &c; 
 x2 = x1; 
 printf("%p\n", x1); 
 printf("%p\n", x2); 
 return 0; 
} 
 
É CORRETO afirmar que: 
 
a) Sua execução apresentará uma mensagem de erro. 
b) O código possui erros léxicos e sintáticos. 
c) A sua execução apresentará na tela o resultado: %p\nx1 %p\nx2. 
d) A sua execução apresentará dois valores iguais. 
e) A sua execução não apresentará mensagens ou resultados. 
 
Comentários: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
94
180
 
O trecho de código apresentado não possui erros léxicos ou sintáticos e sua execução imprimirá na tela dois 
valores iguais, que representam o endereço de memória da variável 'c', que foi atribuído aos ponteiros 'x1' 
e 'x2'. O código apresentado cria três variáveis: um inteiro c, e dois ponteiros para inteiros x1 e x2. Em 
seguida, o ponteiro x1 é inicializado com o endereço de memória da variável c, através do operador "&". O 
ponteiro x2 é atribuído com o valor do ponteiro x1, ou seja, ambos os ponteiros apontam para o mesmo 
endereço de memória. Por fim, são impressos na tela os valores dos ponteiros x1 e x2, utilizando o 
especificador de formato "%p", que imprime o valor do ponteiro como um endereço hexadecimal na 
memória. Como ambos os ponteiros apontam para o mesmo endereço, a impressão dos dois valores será 
igual, resultando na impressão de dois endereços de memória iguais na tela. Caso você tenha alguma dúvida 
em relação ás demais alternativas, vamos analisar cada uma delas. a) A alternativa (a) afirma que a execução 
do código apresentará uma mensagem de erro, o que não é verdade. O código está correto e não apresenta 
nenhum erro durante a sua execução. b) A alternativa (b) afirma que o código possui erros léxicos e 
sintáticos, o que também não é verdade. O código está escrito de forma correta e pode ser compilado sem 
problemas. c) A alternativa (c) afirma que a execução do código apresentará na tela o resultado: %p\nx1 
%p\nx2, o que não é verdade. O código usa a função printf para imprimir o valor dos ponteiros, mas a saída 
correta seria apresentar dois endereços de memória diferentes, e não a string "%p\nx1 %p\nx2". e) A 
alternativa (e) afirma que a execução não apresentará mensagens ou resultados, o que não é verdade. A 
função printf é usada para imprimir os valores dos ponteiros na tela. 
 
Gabarito: Letra D 
 
39. (IF-MT – IF-MT – 2019) Considere o trecho de código escrito na linguagem C apresentado a seguir: 
 
#include <stdio.h> 
 
int MinhaFuncao(int a, int b) { 
 return a/**//b; 
} 
 
int main() { 
 printf("%d", MinhaFuncao (2,3)); 
 return 1; 
} 
 
Assinale a alternativa que apresenta o resultado da sua execução: 
 
a) 1.5 
b) 0.66667 
c) 0 
d) 1 
e) 8 
 
Comentários: 
 
O resultado da execução do código apresentado será "0". Isso ocorre porque a função "MinhaFuncao" realiza 
uma divisão entre dois inteiros utilizando o operador "/", que retorna o resultado da divisão inteira. No caso 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
95
180
em questão, 2 dividido por 3 resulta em 0,66, que arredondado para o inteiro mais próximo resulta em 0. 
Assim, a função retorna 0, que é impresso pelo printf no main. 
 
Gabarito: Letra C 
 
40. (COMPERVE – UFRN – 219) A linguagem de programação C está entre as linguagens de programação 
mais utilizadas para desenvolvimento de bibliotecas e sistemas operacionais pelas suas características de 
portabilidade e desempenho. É uma linguagem baseada em ponteiros que possui diversas formas de 
acesso ao conteúdo da memória. Dada uma matriz A com n colunas armazenada continuamente na 
memória, a lista de expressões que contém formas equivalentes de acesso ao mesmo conteúdo da 
memória é 
 
a) A[i][j], (&A+i*n+j), e A[i*n+j]. 
b) A[i][j], &(A+i*n*j), e A[i*n*j]. 
c) A[i][j], (*A+i*n*j), e A[i*n*j]. 
d) A[i][j], *(A+i*n+j), e A[i*n+j]. 
 
Comentários: 
 
A lista de expressões equivalentes é A[i][j], (A+in+j), e A[in+j]. A primeira expressão A[i][j] é a forma mais 
comum de acesso a um elemento da matriz. A segunda expressão (A+in+j) utiliza aritmética de ponteiros 
para acessar o elemento (i,j) da matriz A. Finalmente, a terceira expressão A[in+j] é uma forma alternativa, 
mas equivalente, de acessar o mesmo elemento usando aritmética de índices. 
 
Gabarito: Letra D 
 
41. (FCC – TRF - 4ª REGIÃO – 2019) As linguagens de programação 
 
a) como Java e C# têm seus códigos fontes transformados em uma linguagem intermediária (específica 
de cada linguagem), que será interpretadapela máquina virtual da linguagem quando o programa for 
executado. 
 
b) como C e Ruby são compiladas estaticamente e seus códigos-fontes são transformados diretamente 
em linguagem de montagem ou assembler. 
 
c) do tipo script como VBScript e Lua são utilizadas em aplicações web. No caso de sites do WordPress, 
por exemplo, os desenvolvedores criam plug-ins e usam o VB para solicitar o conteúdo. O código é 
executado como HTML, permitindo que os visitantes do site visualizem o conteúdo em seus navegadores. 
 
d) orientadas a objeto são todas compiladas e não interpretadas, por isso são consideradas de baixo 
nível, sendo as mais utilizadas para programação de sistemas embarcados ou aplicações que exijam 
acesso direto a registros da memória. 
 
e) interpretadas têm seu código-fonte traduzido por um programa tradutor ou assembly, que em seguida 
é executado pelo sistema operacional. Um exemplo disso é o Bytecode, que é uma linguagem que passa 
pelo processo de interpretação e, em seguida, é executada por um compilador. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
96
180
Comentários: 
 
Linguagens de programação como Java e C# utilizam um processo de compilação em duas etapas, em que o 
código-fonte é primeiro compilado para uma linguagem intermediária (Java bytecode e CIL, 
respectivamente), que é interpretada pela máquina virtual da linguagem quando o programa é executado. 
Esse processo é conhecido como compilação just-in-time (JIT). Essa abordagem oferece várias vantagens, 
como a portabilidade do código-fonte, já que a máquina virtual é executada em diferentes sistemas 
operacionais, e a segurança, já que a máquina virtual isola o programa do sistema operacional hospedeiro. 
Vejamos as demais alternativas. B) Em linguagens de programação como C e Ruby, o código-fonte é 
compilado diretamente para linguagem de máquina ou código de montagem (assembler). Essa abordagem 
é conhecida como compilação estática. O código gerado é específico para a plataforma em que a compilação 
ocorre e, portanto, não é portátil. C) Linguagens de script, como VBScript e Lua, podem ser utilizadas em 
aplicações web, mas o exemplo dado na alternativa não é preciso. Os plugins para o WordPress, por exemplo, 
geralmente são escritos em PHP e não em VBScript. O VBScript é uma linguagem de script da Microsoft que 
é executada em ambientes Windows. Além disso, o código em linguagens de script é interpretado, não 
compilado. D) Linguagens orientadas a objetos, como Java e C++, podem ser compiladas ou interpretadas, 
dependendo da implementação. Elas não são consideradas de baixo nível, já que o paradigma de 
programação orientada a objetos é relativamente alto nível e abstrato. Sistemas embarcados geralmente 
usam linguagens de baixo nível, como C ou Assembly. E) Linguagens interpretadas, como Python e Ruby, são 
traduzidas para código de máquina em tempo de execução por um programa chamado interpretador. O 
bytecode mencionado na alternativa é uma forma intermediária de código gerado por algumas linguagens 
interpretadas, como Java e Python. O bytecode é então interpretado pelo interpretador da linguagem para 
executar o programa. 
 
Gabarito: Letra A 
 
42. (NC-UFPR – ITAIPU BINACIONAL – 2019) Considere o programa abaixo: 
 
Assinale a alternativa que indica corretamente a quantidade de vezes que a palavra “prova” será 
impressa: 
 
#include <stdio.h> 
 
int main() { 
 printf("prova"); 
 main(); 
 return 10; 
} 
 
a) nenhuma. 
b) infinitas vezes. 
c) uma vez. 
d) dez vezes. 
e) será impressa continuamente até que ocorra o estouro da pilha. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
97
180
A resposta correta é a letra E. O programa apresenta uma chamada recursiva infinita da função main(), o que 
fará com que a string "prova" seja impressa continuamente até que ocorra o estouro da pilha de execução. 
Essa é uma situação conhecida como "stack overflow". O retorno return 10 não será alcançado. 
 
Gabarito: Letra E 
 
43. (NC-UFPR – ITAIPU BINACIONAL – 2019) Um programador escreve o programa abaixo e tenta compilar 
e executar. 
 
#include "stdio.h" 
 
int main() { 
 int i; 
 goto LOOP; 
 for (i = 0; i < 10; i++) { 
 printf("sucesso"); 
 LOOP: break; 
 } 
 return 0; 
} 
 
Assinale a alternativa que indica corretamente o que deve ocorrer: 
 
a) O programa não compila. 
b) O programa compila com sucesso, mas não imprime nada quando executado. 
c) O programa compila com sucesso, e quando executado imprime “sucesso” uma vez. 
d) O programa compila com sucesso, mas apresentará erro de execução. 
e) O programa compila com sucesso, e quando executado imprime “sucesso” dez vezes. 
 
Comentários: 
 
O programa compila com sucesso, mas não imprime nada quando executado, pois a instrução goto LOOP 
redireciona a execução do programa para a label LOOP que está logo abaixo, e a instrução break dentro do 
laço de repetição faz com que ele saia imediatamente, sem executar o printf. Portanto, o laço de repetição 
é executado apenas uma vez, e depois o programa é finalizado sem imprimir nada. 
 
Gabarito: Letra B 
 
44. (NC-UFPR – ITAIPU BINACIONAL – 2019) Considere o programa abaixo, escrito em linguagem C: 
 
#include <stdio.h> 
 
int i, j, k; 
 
int main() { 
 for (i = 0, j = 1, k = 2; i < k; i++) { 
 } 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
98
180
 k = k + i % 2; 
 printf("%d,%d,%d", i, j, k); 
 return 0; 
} 
 
Assinale a alternativa que indica o que será impresso por esse programa. 
 
a) 0, 1, 2 
b) 1, 2, 3 
c) 3, 1, 3 
d) 3, 2, 1 
e) 3, 1, 2 
 
Comentários: 
 
A condição do loop é i<k, e como inicialmente k=2 e i=0, o loop não será executado nenhuma vez. Em seguida, 
k é atualizado para k+i%2, que é igual a 2+0%2, resultando em k=2. Por fim, é impresso o valor de i, j e k, que 
são respectivamente 0, 1 e 3. Portanto, a alternativa correta é a letra C. 
Gabarito: Letra C 
 
45. (IF-SP – IF-SP – 2019) Nas linguagens de programação Java e C++, o polimorfismo paramétrico é 
materializado, respectivamente, pelas funcionalidades e/ou características: 
 
a) Genéricos e Templates. 
b) Genéricos e Sobrecarga de Operadores. 
c) Sobrecarga e Templates. 
d) Anotações e Sobrescrita. 
 
Comentários: 
 
Vamos analisar cada alternativa: A) Genéricos e Templates: em Java, o polimorfismo paramétrico é 
implementado através do recurso de "genéricos", que permite criar classes e métodos que possam ser 
usados com tipos diferentes de objetos, sem a necessidade de criar várias versões da mesma classe ou 
método. Em C++, o polimorfismo paramétrico é implementado através de "templates", que permitem criar 
classes e funções genéricas que possam ser usadas com diferentes tipos de dados. B) Genéricos e Sobrecarga 
de Operadores: a sobrecarga de operadores permite que um mesmo operador tenha comportamentos 
diferentes dependendo dos tipos de dados que estão sendo usados. Isso permite criar funções genéricas que 
possam ser aplicadas a diferentes tipos de dados. Em Java, a sobrecarga de operadores não é suportada, mas 
os genéricos podem ser usados para criar funções genéricas. Em C++, a sobrecarga de operadores é 
suportada e pode ser combinada com templates para criar funções genéricas que trabalham com diferentes 
tipos de dados. C) Sobrecarga e Templates: a sobrecarga permite criar funções e métodos com o mesmo 
nome,mas com comportamentos diferentes, dependendo dos parâmetros que são passados. Isso permite 
criar funções genéricas que possam ser usadas com diferentes tipos de dados. Em Java, a sobrecarga é 
suportada, mas os genéricos são a principal ferramenta para criar funções genéricas. Em C++, a sobrecarga 
é suportada e pode ser combinada com templates para criar funções genéricas que trabalham com 
diferentes tipos de dados. D) Anotações e Sobrescrita: a sobrescrita (ou "override") é uma técnica que 
permite que uma classe filha substitua um método da classe pai, mantendo o mesmo nome, mas com 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
99
180
comportamento diferente. Isso não tem relação direta com o polimorfismo paramétrico. Já as anotações são 
utilizadas em Java para adicionar metadados a classes e métodos, o que pode ser útil em alguns casos, mas 
não está diretamente relacionado com o polimorfismo paramétrico. Em C++, não há suporte para anotações. 
 
Gabarito: Letra A 
 
46. (FAURGS – UFCSPA - RS – 2018) Analise o trecho de código abaixo, escrito em C++. 
 
class classe_base { 
private: 
 int a; 
 float x; 
protected: 
 int b; 
 float y; 
public: 
 int c; 
 float z; 
}; 
 
class subclasse_1 : public classe_base {...}; 
 
class subclasse_2 : private classe_base {...}; 
 
class subclasse_3 : private classe_base {...}; 
Com base nesse código, é correto afirmar que 
 
a) na subclasse_1 os atributos b e y são protegidos. 
b) na subclasse_1 os atributos c e z são privados. 
c) na subclasse_2 os atributos b e y são públicos. 
d) na subclasse_2 os atributos c e z são protegidos. 
e) as instâncias da subclasse_3 podem acessar o atributo c. 
 
Comentários: 
 
Na subclasse_1, a classe derivada herdou a classe base com a palavra-chave "public". Isso significa que os 
membros públicos e protegidos da classe base serão herdados como protegidos pela subclasse. Portanto, a 
subclasse_1 terá os atributos b e y protegidos. As demais afirmativas estão incorretas: Na subclasse_1, os 
atributos c e z são públicos. Na subclasse_2, os atributos da classe base serão privados. Na subclasse_3, os 
atributos da classe base serão privados, e as instâncias da subclasse_3 não podem acessar o atributo c 
diretamente. 
Gabarito: Letra A 
 
47. (COTEC – Câmara de Rio Pardo de Minas - MG – 2018) Analise o código a seguir, escrito na linguagem 
de programação C. 
 
#include <stdio.h> 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
100
180
 
void sub(int *x, int y){ 
 *x = 3; 
 y = *x + 1; 
} 
 
int main() { 
 int a, b, z; 
 a = 1; 
 b = 2; 
 sub(&a,b); 
 z = a + b; 
 printf("%d",z); 
 return 0; 
} 
 
O valor de Z, a ser mostrado na saída padrão, é: 
 
a) 3. 
b) 4. 
c) 5. 
d) 7. 
 
Comentários: 
 
No código, a função sub é chamada com o endereço da variável a e o valor da variável b como parâmetros. 
Dentro da função sub, o valor do inteiro apontado pelo ponteiro x é definido como 3, mas o valor de y 
passado como parâmetro não é afetado. Em seguida, no main, a variável z é definida como a soma de a (que 
agora tem valor 3) e b (que mantém seu valor original de 2), resultando em z igual a 5. Por fim, o valor de z 
é impresso na tela com o comando printf("%d", z);. 
 
Gabarito: Letra C 
 
48. (INSTITUTO AOCP – ITEP - RN – 2018) Em C++, como se denomina um conjunto de funções que 
compartilha um mesmo nome, porém contendo um código independente em cada uma? 
 
a) Redundância. 
b) Objeto. 
c) Encapsulamento. 
d) Polimorfismo. 
e) Herança. 
 
Comentários: 
 
A resposta correta é D - Polimorfismo. Em C++, um conjunto de funções que compartilha o mesmo nome, 
mas possui um código independente em cada uma, é conhecido como funções polimórficas. O polimorfismo 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
101
180
é uma técnica que permite que objetos de diferentes classes sejam tratados como se fossem do mesmo tipo, 
e é um dos pilares da programação orientada a objetos. 
 
Gabarito: Letra D 
 
49. (INSTITUTO AOCP – ITEP - RN – 2018) Na linguagem C++, qual é a palavra-chave utilizada para a criação 
de novos tipos de dados? 
 
a) setw. 
b) while. 
c) struct. 
d) #include. 
e) #define. 
 
Comentários: 
 
A resposta correta é a alternativa "c) struct". A palavra-chave "struct" é utilizada na linguagem C++ para a 
criação de novos tipos de dados definidos pelo usuário. Com ela, é possível definir uma estrutura de dados 
contendo vários campos, cada um com seu próprio tipo. Essa estrutura pode ser usada para criar objetos do 
tipo definido pela estrutura, permitindo assim que o programador crie tipos de dados mais complexos e 
adaptados às suas necessidades. As outras alternativas apresentadas na questão são: 
 
a) "setw" é uma função da biblioteca padrão que permite definir a largura do campo de impressão em saídas 
formatadas para a tela ou arquivo. 
 
b) "while" é uma palavra-chave utilizada na linguagem C++ para implementar laços de repetição enquanto 
uma determinada condição é verdadeira. 
 
d) "#include" é uma diretiva do pré-processador que permite incluir o conteúdo de um arquivo de cabeçalho 
em um programa C++. 
 
e) "#define" é uma diretiva do pré-processador que permite definir uma constante ou um macro em um 
programa C++. 
Gabarito: Letra C 
 
50. (INSTITUTO AOCP – ITEP - RN – 2018) Qual das alternativas a seguir apresenta somente tipos de dados 
básicos da linguagem C? 
 
a) char, int e float. 
b) string, double e int. 
c) boolean, string e float. 
d) char, boolean e int. 
e) string, float e int. 
 
Comentários: 
 
A resposta correta é a alternativa a) char, int e float. Os tipos de dados básicos da linguagem C são: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
102
180
 
• char: tipo que representa caracteres. 
• int: tipo que representa números inteiros. 
• float: tipo que representa números de ponto flutuante de precisão simples. 
 
As outras alternativas apresentam pelo menos um tipo de dado que não é considerado básico na linguagem 
C: 
 
b) string: não é um tipo de dado básico na linguagem C, mas pode ser representado utilizando um array de 
caracteres. 
c) boolean e string: a linguagem C não possui um tipo de dado booleano nativo, e string também não é um 
tipo básico. 
d) boolean: como mencionado anteriormente, a linguagem C não possui um tipo de dado booleano nativo. 
e) string: novamente, string não é um tipo de dado básico na linguagem C. 
Portanto, apenas a alternativa a) apresenta somente tipos de dados básicos da linguagem C. 
 
Gabarito: Letra A 
 
51. (INSTITUTO AOCP – ITEP - RN – 2018) Em relação às principais caraterísticas da linguagem C, assinale a 
alternativa correta. 
 
a) Por ser uma linguagem de alto nível, não permite a manipulação de bits, bytes e endereços. 
b) Os códigos em C desenvolvidos para um determinado tipo de sistema operacional não são portáveis 
para outro sistema. Em outras palavras, a linguagem C não possui portabilidade. 
c) A linguagem C é estruturada em blocos, de modo que permite a criação de funções dentro de funções. 
d) A linguagem C permite a compartimentalização de código, escondendo do resto do programa as 
informações necessárias para realizaruma tarefa específica. 
e) É uma linguagem orientada a objeto. 
 
Comentários: 
 
a) ERRADO. A linguagem C permite a manipulação de bits, bytes e endereços, por isso é comumente utilizada 
em programação de sistemas embarcados e de baixo nível. 
b) ERRADO. Embora a portabilidade possa ser um problema em alguns casos, a linguagem C é conhecida por 
sua alta portabilidade, o que significa que o mesmo código pode ser compilado e executado em diferentes 
plataformas e sistemas operacionais. 
c) ERRADO. A linguagem C não permite a criação de funções dentro de outras funções, já que a função tem 
que ser declarada antes ou depois do escopo principal (main) do programa. 
d) CORRETO. Uma das principais características da linguagem C é a capacidade de dividir o código em funções 
e módulos, permitindo a criação de bibliotecas e a reutilização de código. Isso facilita a manutenção do 
código e torna o programa mais modular e organizado. 
e) ERRADO. A linguagem C não é uma linguagem orientada a objetos, embora possa ser usada para 
programação orientada a objetos com a utilização de bibliotecas e estruturas de dados personalizadas. 
 
Gabarito: Letra D 
 
52. (IBADE – IPM - JP – 2018) Considere o seguinte programa escrito na linguagem C 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
103
180
 
#include <stdio.h> 
main () 
{char ex3[5]={'z','k','w','x','v'}; 
int cont1; 
cont1=2; 
printf ("%c %c",ex3[cont1+1], ex3[4]+cont1);} 
 
Ao executar esse programa, é apresentado como resposta: 
 
a) w w 
b) w x 
c) w v 
d) x x 
e) x v 
 
Comentários: 
 
O programa declara um array de caracteres "ex3" com tamanho 5 e preenche com as letras z, k, w, x, v. Em 
seguida, é declarada uma variável inteira "cont1" e é atribuído o valor 2. Na linha seguinte, é impresso o 
conteúdo da posição "cont1+1" do array "ex3", que é o elemento de índice 3 (w). Na segunda parte do 
comando printf é impressa a soma do elemento de índice 4 do array "ex3" (v) com o valor de "cont1" (2), 
resultando na letra x. Portanto, a resposta correta é a letra B: "w x". 
Gabarito: Letra D 
 
53. (IBADE – Câmara de Cacoal - RO– 2018) Considere o seguinte programa escrito na linguagem C 
 
#include <stdio.h> 
 
int main() { 
 int g=0,i=0,l=0,k=0; 
 int m,n,o; 
 
 while (i<=10) { 
 m=g++; 
 n=+l; 
 o=++k; 
 i++; 
 } 
 printf (" m=%d n=%d o=%d ", m,n,o); 
 return 0; 
} 
 
Ao executar esse programa, os valores finais de ,e são respectivamente: 
 
a) 10 0 11 
b) 10 0 12 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
104
180
c) 10 10 11 
d) 11 0 11 
e) 11 10 12 
 
Comentários: 
 
O programa apresentado define algumas variáveis inteiras e inicia cada uma delas com zero. Em seguida, um 
loop while é iniciado, e a cada iteração, as variáveis m, n e o recebem valores de expressões que contêm as 
variáveis g, l e k. m recebe o valor de g pós-incrementado, enquanto n recebe o valor de l sem alteração. Já 
o recebe o valor de k pré-incrementado. O loop while é executado enquanto i for menor ou igual a 10, e a 
cada iteração o valor de i é incrementado. No final do programa, é chamada a função printf para exibir os 
valores finais das variáveis m, n e o. Como g é pós-incrementado a cada iteração do loop, m receberá o valor 
de 10, já que a última atribuição a g é feita quando i é igual a 10. Como n recebe sempre o valor de l, que é 
zero em todas as iterações, n será igual a 0. Já o recebe o valor de k pré-incrementado a cada iteração, por 
isso será igual a 11 no final do loop. Portanto, a resposta correta é a alternativa A: 10 0 11. 
 
Gabarito: Letra A 
 
54. (IBFC – Prefeitura de Divinópolis - MG – 2018) Referente à linguagem de programação C++, uma de suas 
características marcantes é a existência de: 
 
a) encapsulamento triplo 
b) herança múltipla 
c) polimorfismo duplo 
d) abstração complexa 
 
Comentários: 
 
Uma das principais características marcantes da linguagem de programação C++ é a herança múltipla, que 
permite a uma classe herdar características de mais de uma classe base. Isso pode tornar o código mais 
flexível e reutilizável, mas também pode tornar a hierarquia de classes mais complexa e difícil de entender. 
O encapsulamento é outra característica importante do C++, que permite que os dados sejam ocultados de 
outras partes do programa para evitar conflitos e garantir a segurança dos dados. O polimorfismo permite 
que objetos de diferentes classes sejam tratados de maneira semelhante, independentemente de suas 
diferenças de implementação. A abstração é uma característica mais ampla que se aplica a muitas linguagens 
de programação, incluindo o C++, e envolve a capacidade de simplificar e generalizar o código para torná-lo 
mais fácil de entender e trabalhar. 
Gabarito: Letra B 
 
55. (COPESE – UFPI – 2018) Analise as assertivas a seguir sobre as linguagens de programação C, C++, Python 
e Java. 
 
I. A linguagem Python é uma linguagem interpretada e imperativa; 
 
II. Java, assim como C++, é um exemplo de linguagem que segue o paradigma de orientação a objetos; 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
105
180
III. O identificador % é utilizado para identificar um comentário que utiliza somente uma linha em um 
programa escrito na linguagem C; 
 
IV. A linguagem de programação JAVA não fornece suporte à criação de tipos definidos pelo usuário. 
 
Assinale a opção referente às assertivas CORRETAS. 
 
a) Está correta somente a assertiva I. 
b) Estão corretas somente as assertivas I e III. 
c) Estão corretas somente as assertivas I e II. 
d) Estão corretas somente as assertivas III e IV. 
e) Estão corretas somente as assertivas II e IV. 
 
Comentários: 
 
A assertiva I está correta, pois Python é uma linguagem de script interpretada e imperativa. 
 
A assertiva II está correta, pois tanto Java quanto C++ são linguagens de programação orientadas a objetos. 
 
A assertiva III está incorreta, pois em C, o identificador para comentários que ocupam uma linha é //, 
enquanto % é utilizado em formatação de saída de dados com a função printf. 
 
A assertiva IV está incorreta, pois Java permite a criação de tipos definidos pelo usuário por meio de classes 
e interfaces. 
Gabarito: Letra C 
 
56. (FAPEC – UFMS – 2018) Considere o código a seguir escrito na linguagem C. 
 
#include <stdio.h> 
int main() 
{ 
 printf ("Valor total: %.1f\n", 9.1415169265); 
 return 0; 
} 
 
Assinale a alternativa que apresenta a saída correta. 
 
a) Valor total: 9.141517 
b) Valor total: 9.1 
c) Valor total: 9.14 
d) Valor total: 9.142 
e) Valor total: 9.141517e+00 
 
Comentários: 
 
A resposta correta é a letra B: Valor total: 9.1. A formatação %.1f indica que apenas um dígito após a vírgula 
deve ser exibido. No número 9.1415169265, o dígito seguinte ao 1 é o 5, que é maior ou igual a 5, portanto, 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
106
180
ocorre o arredondamento para 9.2. No entanto, como foi especificado apenas um dígito após a vírgula, o 
resultado final é 9.1. 
Gabarito: Letra B 
 
57. (FAPEC – UFMS – 2018) Considere as afirmações sobre a linguagem C. 
 
I - É considerada uma linguagem fortemente tipada. 
 
II - É uma linguagemorientada a objetos. 
 
III - A função scanf é utilizada para ler dados da entrada padrão. 
 
Está(ão) correta(s): 
 
a) Apenas I. 
b) Apenas II. 
c) Apenas I e III. 
d) Apenas II e III. 
e) I, II e III. 
 
Comentários: 
 
A assertiva I está correta, pois a linguagem C é considerada uma linguagem fortemente tipada, o que significa 
que o tipo das variáveis deve ser definido antes de serem utilizadas e não podem ser implicitamente 
convertidas para outros tipos. A assertiva II está incorreta, pois a linguagem C não é orientada a objetos, 
embora permita a programação estruturada. A assertiva III está correta, pois a função scanf é utilizada para 
ler dados da entrada padrão, como teclado, e armazená-los nas variáveis correspondentes. 
 
Gabarito: Letra C 
 
58. (UFTM – UFTM – 2018) Aponte, dentre as alternativas, os resultados da resolução da seguinte expressão 
lógica escrita na linguagem C, para os valores de A, B e C, definidos nos cenários I, II e III: 
 
(A &&B ) && ((C || A || B) || ( !A && C)) 
 
I: A=true, B=true, C=false 
II: A=false, B=true, C=true 
III: A=false, B=true, C=false 
 
a) I: true, II: false, III: false. 
b) I: true, II: true, III: false. 
c) I: false, II: false, III: false. 
d) I: false, II: true, III: false. 
 
Comentários: 
 
Para o cenário I temos: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
107
180
 
(A && B) && ((C || A || B) || (!A && C)) 
(true && true) && ((false || true || true) || (!true && false)) 
true && true 
true 
 
Para o cenário II temos: 
 
(A && B) && ((C || A || B) || (!A && C)) 
(false && true) && ((true || false || true) || (!false && true)) 
false && true 
false 
 
Para o cenário III temos: 
 
(A && B) && ((C || A || B) || (!A && C)) 
(false && true) && ((false || false || true) || (!false && false)) 
false && true 
false 
 
Logo, a alternativa correta é a A. 
Gabarito: Letra A 
 
59. (UFTM – UFTM – 2018) Considere o trecho de código em C abaixo: 
 
#include <stdio.h> 
 
void troca(int a, int b) { 
 int temp = a; 
 a = b; 
 b = temp; 
} 
 
int calcula(int a, int b, int *c) { 
 *c = a - b; 
 return a * (b + 1); 
} 
 
int main() { 
 int x, y, w, z; 
 x = 5; 
 y = 4; 
 troca(x, y); 
 z = calcula(x, y, &w); 
 printf("%d,%d", w, z); 
 return 0; 
} 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
108
180
 
O que será exibido no console, quando a função main for executada? 
 
a) 1,25 
b) -1,24 
c) 1,24 
d) -1,25 
 
Comentários: 
 
No trecho de código fornecido, a função "troca" não está realizando a troca de fato, pois os parâmetros são 
passados por valor e não por referência. Portanto, as variáveis x e y na função main permanecem inalteradas. 
Em seguida, a função "calcula" é chamada com x=5 e y=4 e um ponteiro para a variável w é passado como 
terceiro argumento. Dentro da função "calcula", é calculado o valor de a-b e armazenado na posição de 
memória apontada por c (ou seja, na variável w na função main), e o valor a*(b+1) é retornado e armazenado 
em z na função main. Por fim, são impressos os valores de w e z separados por vírgula. Como a=5 e b=4, 
temos que c=a-b=1 e a*(b+1)=5*5=25. Portanto, os valores impressos serão "1,25". 
 
Gabarito: Letra A 
 
60. (UFES – UFES – 2018) Analise o trecho de código C++ abaixo. 
#include <stdio.h> 
 
class MinhaClasse { 
private: 
 int a; 
 
public: 
 MinhaClasse(int b) { 
 a = b; 
 ImprimeA(); 
 } 
 
 ~MinhaClasse() { 
 IncrementaA(); 
 ImprimeA(); 
 } 
 
 void IncrementaA() { 
 a++; 
 } 
 
 void ImprimeA() { 
 printf("[%d]", a); 
 } 
}; 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
109
180
int main() { 
 MinhaClasse *mClasseD = new MinhaClasse(1); 
 MinhaClasse mClasseE(10); 
 return 0; 
} 
 
Considerando os conceitos de gerenciamento dinâmico de memória, o código C++ acima imprimirá na 
saída padrão: 
a) [1][10][11][2] 
b) [1][10][2][11] 
c) [1][10][11] 
d) [1][10][2] 
e) [1][10] 
 
Comentários: 
 
A resposta correta é a alternativa C: "[1][10][11]". Isso porque o código cria duas instâncias da classe 
MinhaClasse: uma através da alocação dinâmica de memória com o operador new e outra na pilha de 
execução da função main(). A primeira instância criada, mClasseD, é criada com o construtor que recebe o 
parâmetro int b com valor 1. Ao imprimir o valor de a, é exibido "[1]". Em seguida, é chamado o destrutor da 
classe MinhaClasse, que incrementa o valor de a para 2 e imprime "[2]". A segunda instância criada, 
mClasseE, é criada na pilha de execução da função main() com o construtor que recebe o parâmetro int b 
com valor 10. Ao imprimir o valor de a, é exibido "[10]". Quando a função main() termina, o destrutor de 
mClasseE é chamado automaticamente, incrementando o valor de a para 11 e imprimindo "[11]". Portanto, 
a saída padrão será "[1][10][11]". 
Gabarito: Letra C 
 
61. (UFES – UFES – 2018) Analise o trecho de código C++ abaixo. 
 
using namespace std; 
int main() { 
 int arr[] = {10, 7, 2, 15, 4}; 
 vector<int> v(arr, arr + 5); 
 vector<int>::iterator it; 
 sort(v.rbegin(), v.rend()); 
 for (it = v.begin(); it != v.end(); it++) 
 printf("[%d]", *it); 
 return 0; 
} 
 
Considerando os conceitos de iteradores e algoritmos presentes na Standard Template Library (STL), o 
código C++ acima imprimirá na saída padrão: 
 
a) [4][15][2][7][10] 
b) [2][4][7][10][15] 
c) [10][7][2][15][4] 
d) [15][10][7][4][2] 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
110
180
e) [7][9][13][15][20] 
 
Comentários: 
 
O trecho de código C++ apresenta a criação de um vetor "arr" com 5 elementos e em seguida é criado um 
objeto da classe vector "v" que recebe como argumentos os elementos do vetor "arr" utilizando a função 
begin e end. Depois é declarado um iterador "it" do tipo vector<int>::iterator para percorrer o vetor "v". Em 
seguida, é chamada a função sort para ordenar o vetor em ordem decrescente, utilizando os iteradores 
rbegin() e rend(). Por fim, é feita a impressão na saída padrão utilizando o iterador "it" e um laço for. Assim, 
a resposta correta é a letra D, que corresponde à impressão dos elementos do vetor ordenados em ordem 
decrescente: [15][10][7][4][2]. 
Gabarito: Letra D 
 
62. (UFES – UFES – 2018) Um recurso relevante da linguagem C++ é o que declara membros de classe como 
static. O objetivo de se declarar um membro de classe como static em C++ é permitir que 
 
a) apenas uma cópia do membro seja compartilhada por todos os objetos da classe. 
b) cada objeto de uma classe tenha sua própria cópia do membro. 
c) o membro seja estático e seu valor não se altere durante a execução do código. 
d) o membro tenha um nome fixo durante a execução do código. 
e) se armazenem valores únicos. 
 
Comentários: 
 
A alternativa A está correta. Ao se declarar um membro de classe como static em C++, apenas uma cópia 
desse membro é criada e compartilhada por todos os objetos da classe, ou seja, não há uma cópia do 
membro para cada objeto criado. Dessa forma, o valor do membro é compartilhado e atualizado para todos 
os objetos que o acessam. Esse recurso pode ser útil em diversas situações, como para armazenarinformações comuns a todos os objetos da classe ou para contar o número de objetos criados daquela classe. 
 
Gabarito: Letra A 
 
63. (UFES – UFES – 2018) Após reconhecer que muitas estruturas de dados e algoritmos são comumente 
utilizadas por programadores em C++, o comitê-padrão adicionou a Standard Template Library (STL) à 
C++ Standard Library. Os contêineres são estruturas de dados baseadas em templates populares. Sobre 
os contêineres da STL em C++, é INCORRETO afirmar: 
 
a) O contêiner set permite pesquisa rápida e não permite duplicatas. 
b) O contêiner priority_queue permite inserções ou exclusões rápidas em sua parte dianteira ou traseira 
e acesso direto a qualquer elemento desse tipo de contêiner. 
c) O contêiner multiset permite pesquisa rápida e duplicatas. 
d) No contêiner stack, o último elemento a entrar é o primeiro a sair. 
e) O contêiner vector permite inserções e exclusões rápidas na parte traseira e acesso direto a qualquer 
elemento desse tipo de contêiner. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
111
180
A afirmativa incorreta é a letra B. O contêiner priority_queue não permite acesso direto a qualquer elemento, 
apenas a inserção ou exclusão rápidas em sua parte dianteira ou traseira. Acesso direto aos elementos é 
permitido em contêineres como vector e deque. As demais afirmativas estão corretas: o set permite pesquisa 
rápida e não permite duplicatas; o multiset permite pesquisa rápida e permite duplicatas; no stack, o último 
elemento a entrar é o primeiro a sair; e o vector permite inserções e exclusões rápidas na parte traseira e 
acesso direto a qualquer elemento. 
Gabarito: Letra B 
 
64. (UFES – UFES – 2018) Observe o trecho de código em C abaixo, que implementa uma função f1 que tem 
uma string como parâmetro. 
 
void fl(char* str) { 
 while (*str) { 
 if (*str == ' ') { 
 *str = '-'; 
 } 
 str++; 
 } 
} 
 
Assumindo que a chamada da função foi feita passando uma string válida qualquer como argumento, é 
CORRETO afirmar sobre o código acima: 
 
a) o código da função entrará em laço infinito ao ser executado, pois, considerando-se uma string na 
linguagem C, a condição de parada está errada. 
b) o objetivo da função é substituir os caracteres do tipo espaço (i.e., ‘ ’) da string recebida por meio do 
parâmetro str por caracteres do tipo traço (i.e., ‘-’). 
c) o código da função acessará uma posição inválida de memória ao ser executado, pois, considerando-
se uma string na linguagem C, o incremento está errado. 
d) a função não fará nenhuma alteração na string recebida pelo parâmetro str, pois a execução nunca 
entrará no comando de laço. 
e) o objetivo da função é verificar se existem caracteres do tipo espaço e responder “verdadeiro”, caso 
haja, ou “falso”, em caso contrário. 
 
Comentários: 
 
A função implementada acima tem como objetivo substituir os caracteres do tipo espaço por traço na string 
recebida por meio do parâmetro str. Portanto, a alternativa correta é a letra b). 
a) o código da função entrará em laço infinito ao ser executado, pois, considerando-se uma string na 
linguagem C, a condição de parada está errada. 
b) o objetivo da função é substituir os caracteres do tipo espaço (i.e., ‘ ’) da string recebida por meio do 
parâmetro str por caracteres do tipo traço (i.e., ‘-’). 
c) o código da função acessará uma posição inválida de memória ao ser executado, pois, considerando-se 
uma string na linguagem C, o incremento está errado. 
d) a função não fará nenhuma alteração na string recebida pelo parâmetro str, pois a execução nunca entrará 
no comando de laço. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
112
180
e) o objetivo da função é verificar se existem caracteres do tipo espaço e responder “verdadeiro”, caso haja, 
ou “falso”, em caso contrário. 
Gabarito: Letra B 
 
65. (UFES – UFES – 2018) O trecho de código em C abaixo implementa uma função f1 para imprimir, na saída 
padrão, a sigla de um estado, composta por dois caracteres e recebida por meio do parâmetro sigla, e, 
em seguida, imprimir um caractere de quebra de linha. 
 
void f1(char* sigla) { 
 char lSigla[2]; 
 lSigla[0] = sigla[0]; 
 lSigla[1] = sigla[1]; 
 printf("%s\n", lSigla); 
} 
 
Analise as afirmativas a seguir, acerca do trecho de código acima: 
I. Os dois caracteres da sigla do estado passada como argumento serão impressos e serão seguidos 
imediatamente por um caractere de quebra de linha. 
 
II. A troca da linha printf("%c%c\n", lSigla[0],lSigla[1]); pela linha original printf("%s\n", lSigla); produziria 
o resultado desejado. 
 
III. Os dois caracteres da sigla do estado passada como argumento serão impressos primeiramente, mas 
não se pode prever o que será impresso entre a segunda letra da sigla e o caractere de quebra de linha. 
 
IV. Não se pode prever nenhum dos caracteres que serão impressos, mesmo que se conheça a sigla do 
estado passada como argumento. 
 
É CORRETO o que se afirma em 
 
a) II e III, apenas. 
b) II, apenas. 
c) IV, apenas. 
d) III, apenas. 
e) I e IV, apenas. 
 
Comentários: 
 
A afirmativa I está correta, já que a função f1 imprime os dois caracteres da sigla seguidos por um caractere 
de quebra de linha. A afirmativa II está incorreta, já que a troca da linha de impressão para printf("%c%c\n", 
lSigla[0],lSigla[1]) irá imprimir os caracteres da sigla separados por um espaço, em vez de serem 
concatenados em uma string. A afirmativa III está correta, já que não há nenhum caractere sendo 
explicitamente colocado entre as duas letras da sigla na impressão, mas a função printf pode inserir alguns 
caracteres especiais, dependendo do sistema operacional e da configuração. A afirmativa IV está incorreta, 
já que a sigla é claramente definida no código e os caracteres que serão impressos podem ser previstos. 
Portanto, a resposta correta é a letra A: II e III, apenas. 
Gabarito: Letra A 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
113
180
 
66. (FADESP – IF-PA – 2018) Analise as afirmações sobre as linguagens de programação. 
 
I. O mecanismo de herança em Java ocorre em tempo de compilação, ou seja, todo reaproveitamento de 
código realizado por herança é imutável em tempo de execução. 
II. A linguagem C++ possui herança múltipla, Java possui somente herança simples para classes concretas 
e abstratas, mas possui herança múltipla para a “interface”, já Javascript não possui herança como 
funcionalidade nativa. 
III. C++ é uma linguagem compilada, Java é compilada para uma linguagem de máquina intermediária 
chamada de bytecodes, sendo esta interpretada e Javascript é interpretada. 
 
É correto afirmar que 
 
a) somente a afirmativa II é verdadeira. 
b) somente as afirmativas I e III são verdadeiras. 
c) somente as afirmativas I e II são verdadeiras. 
d) somente a afirmativa III é verdadeira. 
e) as afirmativas I, II e III são verdadeiras. 
 
Comentários: 
 
A questão apresenta algumas afirmações sobre linguagens de programação e pede que o candidato analise 
cada uma delas e determine a correta. A primeira afirmação é correta e se refere ao mecanismo de herança 
em Java, que é determinado em tempo de compilação e não pode ser alterado em tempo de execução. Já a 
segunda afirmação é incorreta ao afirmar que JavaScript não possui herança como funcionalidade nativa. De 
fato, a linguagem possui suporte à herança, emborade uma maneira diferente da maioria das outras 
linguagens. A terceira afirmação é correta e se refere à maneira como as linguagens C++, Java e JavaScript 
são compiladas ou interpretadas. Assim, a alternativa correta é a letra B, que afirma que somente as 
afirmações I e III são verdadeiras. 
Gabarito: Letra B 
 
67. (NUCEPE – SEDUC-PI – 2018) A estrutura de repetição for possui três campos que devem ser preenchidos. 
Conforme o exemplo a seguir, esses três campos são chamados respectivamente de: 
 
for (contador = 1; contador <= 10; contador++) 
{ 
 printf("%d", contador); 
} 
getch(); 
return(0); 
} 
 
a) inicialização, condição e iteração. 
b) incremento, condição e inicialização. 
c) condição, inicialização e incremento. 
d) inicialização, condição e iteração. 
e) inicialização, condição e iteração. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
114
180
 
Comentários: 
 
A alternativa correta é a letra E: inicialização, condição e iteração. Os três campos da estrutura de repetição 
for são, nessa ordem: a inicialização da variável de controle, a condição para a execução do loop e a iteração 
da variável de controle. No exemplo dado, a variável "contador" é inicializada com o valor 1, a condição de 
execução é que o contador seja menor ou igual a 10 e a iteração é feita através do incremento do contador 
em uma unidade a cada iteração do loop. 
Gabarito: Letra E 
 
68. (NUCEPE – SEDUC-PI – 2018) Analise o trecho do código a seguir e marque a única alternativa CORRETA 
em relação ao resultado da execução do programa. 
 
#include <iostream> 
 
void impr3() { 
 std::cout << "3" << std::endl; 
} 
 
void impr2() {} 
 
void impr1() { 
 std::cout << "1" << std::endl; 
} 
 
int main() { 
 impr3(); 
 std::cout << "2" << std::endl; 
 impr1(); 
 impr2(); 
 return 0; 
} 
 
a) 2 3 1 
b) 1 3 2 
c) 1 2 3 
d) 3 2 1 
e) 2 1 3 
 
Comentários: 
 
A resposta correta é a alternativa B, que corresponde à sequência de saída "1 3 2". Isso porque a função 
impr3() é chamada logo no início do programa, imprimindo o número 3. Em seguida, o número 2 é impresso 
com o comando "std::cout << "2" << std::endl;", e depois a função impr1() é chamada, imprimindo o número 
1. A função impr2() não tem nenhum comando dentro dela e não produz saída. Portanto, a sequência correta 
de saída é "1 3 2". 
Gabarito: Letra B 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
115
180
 
69. (NUCEPE – SEDUC-PI – 2018) De acordo com o código a seguir, qual comando estaria no lugar de 
***************? 
 
#include <iostream> 
 
int main(int argc, char *argv[]) { 
 int num1, num2; 
 std::cout << "Digite um numero: "; 
 *************** 
 std::cout << "Digite outro numero: "; 
 std::cin >> num1; 
 std::cout << "Os números digitados foram " << num1 << " e " << num2 << std::endl; 
 return 0; 
} 
 
a) scanf ("%d", &num3). 
b) scanf ("%d", &num1). 
c) scanf ("%d", &num2). 
d) scanf ("%f", &num2). 
e) scanf ("%f", &num1). 
 
Comentários: 
 
O código é um programa simples em C++ que solicita que o usuário digite dois números e os exibe na tela. O 
programa começa declarando duas variáveis inteiras, num1 e num2, e em seguida utiliza a biblioteca 
iostream para imprimir a mensagem "Digite um número:" na tela. Em seguida, o programa utiliza o operador 
de extração (>>) para obter um valor digitado pelo usuário e armazená-lo na variável num2. O programa 
então imprime outra mensagem "Digite outro número:", utilizando a mesma sintaxe. Depois disso, o 
operador de extração (>>) é utilizado novamente para obter um segundo valor digitado pelo usuário e 
armazená-lo na variável num1. Finalmente, o programa imprime uma mensagem que combina os valores de 
num1 e num2 e encerra sua execução. O comando correto para ler um valor inteiro do usuário e armazená-
lo na variável num2 em C++ é "std::cin >> num2;". O comando scanf é utilizado em C para a mesma finalidade. 
 
Gabarito: Letra C 
 
70. (NUCEPE – SEDUC-PI – 2018) O programa em linguagem C abaixo imprime os números pares que estão 
no intervalo de 0 a 50, em ordem crescente. Qual o incremento correto? 
 
int i 
 for (i=0; i<=50; ****X{ 
 printf("%d ", i); 
} 
 
a) i++ 
b) cont = cont + 1 
c) cont = i++ 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
116
180
d) i = i + 1 
e) i = i + 2 
 
Comentários: 
 
O incremento correto seria a alternativa E, isto é, "i = i + 2". Isso porque o objetivo é imprimir somente 
números pares, e como todo número par é divisível por 2, é necessário incrementar o valor de i com um 
passo de 2 em 2 para que sejam considerados somente os números pares no intervalo de 0 a 50. 
 
Gabarito: Letra E 
 
71. (UFMT – UFSBA – 2017) A sobrecarga de operadores é uma técnica muito utilizada em C++. Assinale a 
alternativa que NÃO apresenta um operador que possa ser sobrecarregado em C++. 
 
a) "new" 
b) "new[]" 
c) "+" 
d) "?:". 
 
Comentários: 
 
A sobrecarga de operadores é uma técnica importante em C++, que permite aos desenvolvedores definir 
comportamentos personalizados para os operadores existentes na linguagem. Os operadores mencionados 
nas opções B e C - "new[]" e "+" - também podem ser sobrecarregados em C++. Vejamos cada alternativa. A) 
"new": "new" é um operador em C++ usado para alocar memória dinamicamente durante a execução de um 
programa. No entanto, esse operador não pode ser sobrecarregado, pois ele é um operador de membro e a 
linguagem C++ não permite a sobrecarga de operadores de membro. B) "new[]": "new[]" é um operador em 
C++ usado para alocar dinamicamente uma matriz de elementos em tempo de execução. Esse operador pode 
ser sobrecarregado para personalizar o comportamento da alocação dinâmica de matrizes. C) "+": "+" é um 
operador em C++ usado para realizar a operação de adição em dois valores. Esse operador pode ser 
sobrecarregado para personalizar o comportamento da adição de valores. D) "?:": "?:", também conhecido 
como operador ternário, é um operador condicional em C++ que retorna um dos dois valores, dependendo 
de uma condição. Esse operador pode ser sobrecarregado para personalizar o comportamento do operador 
ternário condicional. 
 
Gabarito: Letra D 
 
72. (UFMT – UFSBA – 2017) Assinale a alternativa que representa, na linguagem de programação C, a 
estrutura de repetição for que, por meio da variável de controle i, percorre o intervalo do índice 0 até o 
índice 32 inclusive, na ordem não decrescente. 
a) for(i = 32; i > 0; i--) 
b) for(i = 32; i > -1; i--) 
c) for(i = 0; i < 33; i++) 
d) for(i = 0; i < 32; i++) 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
117
180
A alternativa que representa, na linguagem de programação C, a estrutura de repetição for que percorre o 
intervalo do índice 0 até o índice 32 inclusive, na ordem não decrescente, é a letra C: for(i = 0; i < 33; i++). 
Nesse loop for, a variável i é inicializada com 0, e a condição de parada é i < 33, que garante que o loop 
execute até que i chegue ao valor 33. O operador de incremento i++ garante que a variável i seja 
incrementada em cada iteração do loop. Assim, o loop executa 33 iterações, percorrendo o intervalo de 0 
até 32 inclusive, em ordem nãodecrescente. 
Gabarito: Letra C 
 
73. (UFRN – UFRN – 2017) Considere o seguinte código em C++ : 
 
int funcl(int paramA, int paramB) { 
 if (paramA > paramB) { 
 return funcl(paramA - paramB, paramB); 
 } else { 
 return paramA; 
 } 
} 
 
Nesse código, o algoritmo func1 implementa uma função matemática de 
 
a) divisão inteira 
b) resto da divisão inteira 
c) fatorial 
d) potenciação 
 
Comentários: 
 
O código em C++ implementa uma função que retorna o resto da divisão inteira de paramA por paramB. A 
função funcl utiliza recursividade para realizar a operação, subtraindo paramB de paramA enquanto paramA 
for maior que paramB. Quando paramA é menor ou igual a paramB, a função simplesmente retorna paramA, 
que será o resto da divisão inteira. Portanto, a alternativa correta é a letra B, que se refere ao resto da divisão 
inteira. 
 
Gabarito: Letra B 
 
74. (IF-CE – IF-CE – 2017) Considere as afirmações sobre os paradigmas de linguagens de programação. 
 
I. Python, Ruby e Java são linguagens de programação interpretada multiparadigma, de tipagem dinâmica 
e forte. 
 
II. As linguagens de programação Object-Pascal, C++ e Java, embora deem suporte à Orientação a Objetos 
(OO), não são completamente orientadas a objetos. 
 
III. As linguagens de programação Smalltalk e Ruby são consideradas puramente orientadas a objetos, 
isto é, tudo é considerado um objeto, até mesmo os tipos básicos da linguagem. 
 
Está(ão) correta(s): 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
118
180
 
a) II, apenas. 
b) I, II e III. 
c) III, apenas. 
d) I e II, apenas. 
e) II e III, apenas. 
 
Comentários: 
 
A resposta correta é a alternativa E. A afirmação I é verdadeira. Python, Ruby e Java são linguagens de 
programação interpretada multiparadigma, de tipagem dinâmica e forte. A afirmação II é falsa. Tanto C++ 
quanto Object-Pascal e Java são linguagens que dão suporte completo à Orientação a Objetos (OO). A 
afirmação III é verdadeira. Smalltalk e Ruby são linguagens consideradas puramente orientadas a objetos, 
pois tudo é considerado um objeto, inclusive os tipos básicos da linguagem. Portanto, as afirmações II e III 
estão corretas, enquanto a afirmação I está incorreta. A alternativa que corresponde a isso é a letra E. 
 
Gabarito: Letra E 
 
75. (IF-CE – IF-CE – 2017) Sabendo-se que programas de computador podem ser compilados ou 
interpretados, é verdadeiro dizer-se que programas 
 
a) desenvolvidos com Java igualmente aos desenvolvidos com C# são compilados. Ambos se utilizam de 
uma linguagem intermediária, para independer do sistema operacional. 
b) em PHP são interpretados tanto quanto programas em Java para web. 
c) em JavaScript funcionam Client-Side, ou seja, rodam no lado cliente, por isso precisam ser previamente 
compilados. 
d) desenvolvidos para internet precisam de um servidor de aplicação como IIS ou Apache. Devido a isso, 
são linguagens interpretadas pelo servidor. 
e) feitos com linguagem que precise de uma máquina virtual ou semelhante, como o Java, são executados 
e interpretados por ela em tempo de execução (Just-in-time), por isso não precisam ser compilados. 
 
Comentários: 
 
Pessoal, nosso gabarito é a letra A. Programas desenvolvidos em Java e C# são compilados e utilizam uma 
linguagem intermediária para serem executados de forma independente do sistema operacional. Essa 
linguagem intermediária é conhecida como bytecode no caso do Java e IL (Intermediate Language) no caso 
do C#. PHP é uma linguagem interpretada, enquanto Java pode ser compilado ou interpretado, dependendo 
da implementação utilizada (por exemplo, a JVM pode compilar o bytecode para código nativo ou interpretá-
lo). JavaScript é uma linguagem interpretada que é executada no navegador do cliente (Client-Side) e não 
precisa ser previamente compilada. Programas desenvolvidos para internet não necessariamente precisam 
de um servidor de aplicação como IIS ou Apache, mas é comum que sejam executados em um ambiente de 
servidor e interpretados pelo servidor antes de serem enviados para o cliente. Linguagens que precisam de 
uma máquina virtual, como Java, geralmente são compiladas para bytecode e depois interpretadas pela 
máquina virtual em tempo de execução (Just-in-time), mas isso não significa que elas não precisam ser 
compiladas. 
 
Gabarito: Letra A 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
119
180
 
76. (IFB – IFB – 2017) Analise as seguintes afirmativas. I) Ocultar dados dentro das classes e torná-los 
disponíveis apenas por meio de métodos é uma técnica muito usada em programas orientados a objetos, 
chamada de sobreescrita de classes. II) Uma subclasse pode implementar novamente métodos que foram 
herdados de uma superclasse. Chamamos isso de sobrecarga de atributos. III) Em Java não existe herança 
múltipla como em C++. Essa limitação pode ser parcialmente simulada pelo uso de encaminhamento de 
métodos a variáveis de instância. Assinale a alternativa CORRETA com relação às afirmativas acima. 
 
a) Apenas a afirmativa I está correta. 
b) Apenas a afirmativa II está correta. 
c) Apenas a afirmativa III está correta. 
d) Apenas as afirmativas I e III estão corretas. 
e) Apenas as afirmativas I e II estão corretas. 
 
Comentários: 
 
A afirmativa I está incorreta, pois a técnica mencionada é chamada de encapsulamento, não de sobreescrita 
de classes. A afirmativa II está incorreta, pois a definição correta de sobrecarga é quando uma classe tem 
vários métodos com o mesmo nome, mas com parâmetros diferentes. A afirmativa III está correta, pois em 
Java não é possível herdar de múltiplas classes, mas é possível implementar múltiplas interfaces e usar o 
encaminhamento de métodos para simular herança múltipla. 
 
Gabarito: Letra C 
 
77. (UFES – UFES – 2016) O código C abaixo se propõe a informar a média da idade de algumas pessoas com 
uma precisão de duas casas decimais, dados o número de pessoas (pessoas, com 0<pessoas<10) e suas 
respectivas idades. 
 
#include <stdio.h> 
 
int main() { 
 int pessoas, i, soma, idade; 
 double media; 
 
 scanf("%d", &pessoas); 
 soma = 0; 
 
 for(i = 0; i < pessoas; i++) { 
 scanf("%d", &idade); 
 soma = soma + idade; 
 } 
 
 media = soma/pessoas; 
 printf("%.2f", media); 
 
 return 0; 
} 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
120
180
 
A respeito do código acima, é CORRETO afirmar: 
a) O código faz corretamente o que é proposto. 
b) O código interrompe sua execução com um segmentation fault. 
c) O código pode ser corrigido para fazer o que se propõe, caso seja feita uma conversão de tipos no local 
apropriado. 
d) O código está errado, pois o formato do printf não é apropriado para impressão com precisão de duas 
casas decimais. 
e) O código está errado, pois a variável idade deveria ser dividida pela variável pessoas dentro do for, ou 
seja, soma = soma + idade/pessoas;. 
 
Comentários: 
 
O código se propõe a calcular a média da idade de um número específico de pessoas e exibir o resultado com 
uma precisão de duas casas decimais. O código faz a leitura do número de pessoas e em seguida lê as idades 
de cada pessoa, somando todas elas em uma variável "soma". Em seguida, o código calcula a média dividindo 
a soma pelo número de pessoas e armazenando o resultado na variável "media". Por fim, o código imprime 
o valor de "media" com precisão de duas casasdecimais usando o formato de saída "%.2f". A opção correta 
é a letra C, pois embora o código esteja funcionando corretamente para o que se propõe, é possível que 
ocorra um erro caso o valor de "pessoas" seja maior ou igual a 10, já que o código não está preparado para 
lidar com esse caso. Além disso, o código poderia ser otimizado para utilizar uma variável do tipo "float" em 
vez de "double", já que a precisão necessária é de apenas duas casas decimais. 
 
Gabarito: Letra C 
 
78. (CESPE – TJ-SE– 2014) Para que a máquina entenda os comandos de um programa desenvolvido na 
linguagem C, o programa deve ser compilado e traduzido para a linguagem da máquina. 
 
Comentários: 
 
Sim, essa afirmação está correta. O código escrito na linguagem C é interpretado pelo compilador da 
linguagem, que é responsável por traduzir o código para a linguagem de máquina que o computador é capaz 
de entender e executar. Sem o processo de compilação, o programa escrito em C não poderia ser executado 
diretamente pela máquina. 
 
Gabarito: Correto 
 
79. (CESPE – TJ-SE– 2014) O comando em linguagem C apresentado abaixo é um tipo de laço que pode ser 
finalizado com o comando break; portanto, esse comando não tem garantia de laço infinito. 
 
for (;;) printf ("Exemplo de laço infinito.\n") ; 
 
Comentários: 
 
O laço for apresentado não tem condição de término, portanto é um laço infinito. No entanto, é possível 
finalizá-lo com o uso do comando break em alguma condição dentro do próprio laço. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
121
180
Gabarito: Correto 
 
80. (CESPE – ANTT – 2014) O paradigma de orientação a objetos é amplamente utilizado em várias 
linguagens: Java é compilada em bytecode e executada em uma máquina virtual (JVM); C++ apresenta 
bom desempenho ao unir características de alto e de baixo níveis; Python/Ruby/PHP podem ser utilizadas 
para desenvolvimento web, mas sem aplicações para dispositivos móveis 
 
Comentários: 
 
A afirmação apresentada está incorreta. Embora Java seja compilada em bytecode e executada em uma 
máquina virtual (JVM), isso não significa que as outras linguagens mencionadas não possam ser usadas para 
desenvolvimento de aplicativos móveis. Na verdade, tanto Python quanto Ruby têm uma grande variedade 
de frameworks e bibliotecas disponíveis para desenvolvimento de aplicativos móveis, como Kivy, PyMob e 
Rubymotion. Além disso, o PHP também pode ser usado para o desenvolvimento de aplicativos móveis, 
embora em menor escala. 
Gabarito: Errado 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
122
180
 
 
 
QUESTÕES COMENTADAS 
Diversas Bancas 
 
1. (VUNESP – UNICAMP – 2022) Na linguagem C++, estruturas (definidas pela palavra-chave struct) podem 
ser passadas como parâmetros em chamadas de funções. Nesse contexto, assinale a alternativa correta. 
 
a) Por padrão, estruturas são passadas por referência. 
b) Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por 
valor requer que a estrutura inteira seja copiada. 
c) Estruturas só podem ser passadas como parâmetro por meio do uso de ponteiros. 
d) É necessário o uso da palavra-chave inline na declaração da função que recebe uma estrutura como 
parâmetro. 
e) Apenas funções do tipo void podem receber estruturas como parâmetros. 
 
Comentários: 
 
Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por valor 
requer que a estrutura inteira seja copiada. Isso pode ser custoso em termos de desempenho se a estrutura 
for grande. Portanto, é comum passar estruturas por referência ou por ponteiros para evitar a cópia 
desnecessária de dados. No entanto, é importante notar que é possível passar estruturas por valor se a 
estrutura for pequena e se a cópia não afetar significativamente o desempenho da função. A letra A está 
incorreta, pois as estruturas podem ser passadas por valor ou por referência, dependendo da necessidade 
do programador. A letra C está incorreta, pois as estruturas podem ser passadas por valor ou por referência, 
não sendo necessário o uso de ponteiros. A letra D está incorreta, pois não é necessário o uso da palavra-
chave inline na declaração da função que recebe uma estrutura como parâmetro. A palavra-chave inline é 
usada para otimizar o desempenho de funções curtas, mas não está diretamente relacionada à passagem de 
estruturas como parâmetros. A letra E está incorreta, pois funções de qualquer tipo (não apenas do tipo 
void) podem receber estruturas como parâmetros. 
 
Gabarito: Letra B 
 
2. (CESPE – PG-DF – 2021) Tendo como referência o código, escrito em linguagem de programação ANSI C, 
julgue o item subsecutivo. 
 
#include <stdio.h> 
 
int main ( ) { 
 int vetor[10], i = 0, j = 0, auxiliar = 0; 
 
 for (i = 0; i < 10; i++) { 
 printf ("Digite um numero inteiro: "); 
 scanf ("%d", &auxiliar); 
 vetor[i] = auxiliar; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
123
180
 
 
 
 } 
 
 for (i = 0; i < 10; i++) { 
 for (j = i+1; j < 10; j++) { 
 if ( vetor[i] > vetor [j]) { 
 auxiliar = vetor [i]; 
 vetor[i] = vetor[j]; 
 vetor[j] = auxiliar; 
 } 
 } 
 } 
 
for (i = 0; i < 10; i++) { 
 printf ("\n\n vetor[%d] = %d", i, vetor[i]); 
 } 
 
 system ("PAUSE"); 
 return 0; 
} 
 
Quando compilado e executado, o código solicita que o usuário digite dez números inteiros e, em 
seguida, ordena e mostra esses números na tela, em ordem crescente. 
 
Comentários: 
 
Este programa em C++ utiliza a biblioteca "vector" para criar um vetor de inteiros chamado "v". Em seguida, 
o programa utiliza um loop "for" para adicionar ao vetor os valores de i multiplicados por 2, ou seja, [0, 2, 4, 
6, 8, 10]. Depois disso, o programa remove os dois primeiros elementos do vetor usando o método "erase". 
Como resultado, o vetor agora tem os valores [4, 6, 8, 10]. Finalmente, o programa usa outro loop "for" para 
imprimir os elementos restantes do vetor. No entanto, há um erro na linha que imprime os elementos. Em 
vez de imprimir o valor do elemento, a variável "i" que representa um iterador é impressa. Para imprimir 
corretamente os valores, deve-se usar "*i" para acessar o valor do elemento no vetor. O código apresentado 
solicita ao usuário que digite 10 números inteiros, armazena esses valores em um vetor e, em seguida, usa o 
algoritmo de ordenação conhecido como "selection sort" para ordenar os números em ordem crescente. Por 
fim, o programa exibe os números ordenados na tela. Portanto, o item está correto. Quando compilado e 
executado, o código solicita que o usuário digite dez números inteiros e, em seguida, ordena e mostra esses 
números na tela, em ordem crescente. 
 
Gabarito: Correto 
 
3. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
Caso a linha for (i = 0; i < 10; i++) { fosse alterada para for (i = 0; i > 10; i++) { em suas três ocorrências, o 
código funcionaria invertendo a ordem dos números digitados e armazenados no vetor declarado no 
código. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
124
180
 
 
 
 
Comentários: 
 
Pessoal, errada a questão! Na verdade, o código não funcionaria corretamente se a linha for (i = 0; i > 10; 
i++) { fosse alterada para as três ocorrências do loop for. Isso ocorre porque a condição do loop for é 
responsável por controlar a quantidade de iterações do loop, e a condição "i > 10" nunca seria satisfeita, pois 
a variável "i" é inicializada com o valor zero e incrementada a cada iteração. Portanto, o loop for nunca seria 
executado e nenhum número seria armazenado no vetor. Caso a intenção seja percorrer o vetor de forma 
invertida, a condição do loop for deveria ser alterada para "i >= 0" e o incremento da variável "i" deveria ser 
trocado para um decremento. 
 
Gabarito: Errado 
 
4. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
 
O comando printf ("\n\n vetor[%d] = %d", i, vetor[i]); continuaria funcionando corretamente mesmo que 
o comando #include não existisse no código. 
 
Comentários: 
 
Pessoal, questão errada! Na verdade, o comando printf não funcionaria corretamente se o comando #include 
correspondente à biblioteca stdio.h não existisse no código. Isso ocorre porque o comando printf faz parte 
da biblioteca padrão de entrada e saída de dados do C, e seu protótipo é definido na biblioteca stdio.h. Se a 
biblioteca não for incluída no código, o compilador não será capaz de reconhecer o comando printf, 
resultando em um erro de compilação. Portanto, é necessário que a biblioteca stdio.h seja incluída no código 
para que o comando printf e outros comandos relacionados à entrada e saída de dados possam ser utilizados 
corretamente. 
 
Gabarito: Errado 
 
5. (CESPE – PG-DF – 2021) Tendo como referência o código da questão anterior, escrito em linguagem de 
programação ANSI C, julgue o item subsecutivo. 
 
O parâmetro %d, utilizado na linha scanf ("%d", &auxiliar);, permite a digitação apenas de números 
inteiros. 
 
Comentários: 
 
Perfeita questão pessoal! O parâmetro %d utilizado na linha scanf ("%d", &auxiliar); permite a leitura de 
números inteiros a partir do teclado. O %d é um especificador de formato utilizado pela função scanf para 
indicar que se espera a leitura de um número inteiro. Quando o usuário digita um número inteiro e pressiona 
a tecla Enter, o valor digitado é armazenado na variável auxiliar passada como argumento para a função 
scanf. Caso o usuário digite um valor que não seja um número inteiro, o comportamento da função scanf 
pode ser imprevisível, podendo ocorrer erros de leitura ou comportamentos inesperados. Portanto, é 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
125
180
 
 
 
importante garantir que o valor digitado pelo usuário seja compatível com o formato especificado pelo 
parâmetro %d. 
 
Gabarito: Correto 
 
6. (VUNESP – UNICAMP – 2022) Considere o seguinte programa na linguagem C++: 
 
#include <iostream> 
#include <vector> 
using namespace std; 
 int main() { 
 vector<int> v; 
 for (int i=0;i<=5;i++) { 
 v.push_back(i*2); 
 } 
 v.erase(v.begin()); 
 v.erase(v.begin()); 
 for (auto i=v.begin();i!=v.end();i++) { 
 cout << i << " "; 
 } 
 } 
 
A saída produzida por sua execução é: 
 
a) 4 6 8 
b) 6 4 2 
c) 2 4 6 8 
d) 4 6 8 10 
e) 8 6 4 2 
 
Comentários: 
 
A saída produzida pelo programa será: 2 4 6 8. Isso ocorre porque o valor i utilizado na linha v.push_back(i*2) 
é o valor de i após a execução do primeiro laço for, ou seja, 6. Portanto, os valores adicionados ao vetor v 
serão 12, que é o dobro de 6, e o laço for que imprime os elementos do vetor v irá imprimir na tela os valores 
4, 6 e 8, que são os elementos restantes após a remoção dos dois primeiros elementos. Assim, a opção 
correta é a letra d) 4 6 8 10. 
Gabarito: Letra D 
 
7. (VUNESP – UNICAMP – 2022) Na linguagem C++, estruturas (definidas pela palavra-chave struct) podem 
ser passadas como parâmetros em chamadas de funções. Nesse contexto, assinale a alternativa correta. 
Alternativas 
a) Por padrão, estruturas são passadas por referência. 
b) Passar estruturas por referência é mais eficiente que passá-las por valor, uma vez que a passagem por 
valor requer que a estrutura inteira seja copiada. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
126
180
 
 
 
c) Estruturas só podem ser passadas como parâmetro por meio do uso de ponteiros. 
d) É necessário o uso da palavra-chave inline na declaração da função que recebe uma estrutura como 
parâmetro. 
e) Apenas funções do tipo void podem receber estruturas como parâmetros. 
 
Comentários: 
 
A alternativa correta é a letra B: Passar estruturas por referência é mais eficiente que passá-las por valor, 
uma vez que a passagem por valor requer que a estrutura inteira seja copiada. Ao passar uma estrutura por 
valor em uma chamada de função, uma cópia completa da estrutura é criada, o que pode ser ineficiente em 
termos de uso de memória e processamento. Por isso, é comum passar estruturas por referência ou por 
ponteiro, que evitam a cópia desnecessária e podem melhorar a eficiência do programa. A opção A está 
incorreta, pois a passagem por referência é uma opção que deve ser explicitamente escolhida na definição 
da função ou na chamada da função, não sendo o padrão. A opção C está incorreta, pois as estruturas podem 
ser passadas tanto por valor quanto por referência (por meio de ponteiros ou referências). As opções D e E 
estão incorretas, pois a palavra-chave inline é usada para otimização do código em tempo de execução e não 
tem relação direta com a passagem de estruturas como parâmetros. Além disso, funções de qualquer tipo 
podem receber estruturas como parâmetros. 
Gabarito: Letra B 
 
8. (VUNESP – UNICAMP – 2022) Na linguagem C++, a linha de código 
 
 double * x,y; 
 
declara 
 
a) duas variáveis do tipo double. 
b) dois ponteiros para valores do tipo double. 
c) um ponteiro para um valor do tipo double e uma variável do tipo double. 
d) uma variável do tipo double e um ponteiro que aponta para ela. 
e) um ponteiro para uma função do tipo double que recebe dois parâmetros também do tipo double. 
 
Comentários: 
 
Em C++, o operador * é usado para declarar um ponteiro, que é uma variável que armazena o endereço de 
memória de outra variável. No código double * x, y;, a declaração double * x cria um ponteiro para um valor 
do tipo double chamado x. Já a declaração y cria uma variável do tipo double chamada y. Note que a 
declaração do ponteiro x só se aplica a ele e não à variável y. Ou seja, y não é um ponteiro e não armazena 
um endereço de memória, mas sim um valor do tipo double. Caso o objetivo fosse declarar dois ponteiros, a 
declaração correta seria double *x, *y;. Nesse caso, tanto x quanto y seriam ponteiros para valores do tipo 
double. Portanto, a alternativa correta é a letra C. 
Gabarito: Letra C 
 
9. (UFMT – Câmara de Cáceres - MT – 2022) A partir do trecho de código abaixo utilizando a linguagem de 
programação C, assinale a alternativa que apresenta a saída da execução do código. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
127
180
 
 
 
 
#include <stdio.h> 
int main() { 
 int i; 
 int vec[] = {1,2,3,4,5}; 
 *(vec + *vec) = vec[1];*(vec + vec[1]) = vec[3]; 
 *(vec + vec[2]) = *(vec + 0); 
 for(i = 0; i < 5; i++) 
 printf("%d", vec[i]); 
 return 0; 
} 
 
a) 1 2 3 1 4 
b) 1 2 3 4 5 
c) 1 2 4 4 1 
d) 1 2 4 4 4 
 
Comentários: 
 
A resposta correta é a alternativa C. Durante a execução do código, a linha *(vec + *vec) = vec[1]; altera o 
valor do segundo elemento do vetor vec para 2 (valor armazenado na posição 1). Em seguida, a linha *(vec 
+ vec[1]) = vec[3]; altera o quarto elemento do vetor vec para 4 (valor armazenado na posição 3). Por fim, a 
linha *(vec + vec[2]) = *(vec + 0); altera o terceiro elemento do vetor vec para 1 (valor armazenado na posição 
0). Ao final, a função printf exibe os valores do vetor vec, que serão: 1 2 4 4 1. A alternativa C é a única que 
apresenta esses valores. 
Gabarito: Letra C 
 
10. (FADENOR – Prefeitura de Dores de Guanhães - MG – 2022) Analise o código a seguir, escrito na 
linguagem de programação C. 
 
#include <stdio.h> 
void sub (int *x, int y){ 
 *x = 3; 
 y = *x + 1; 
} 
int main() 
{ 
 int a, b, z; 
 a = 1; 
 b = 2; 
 sub(&a,b); 
 z=a+b; 
 printf("%d",z); 
 return 0; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
128
180
 
 
 
} 
 
O valor de Z, a ser mostrado na saída padrão, é 
 
a) 3. 
b) 4. 
c) 5. 
d) 7. 
e) 9. 
 
Comentários: 
 
O valor de Z será igual a 5. O programa define uma função chamada "sub" que recebe um ponteiro para 
inteiro (x) e um inteiro (y). Dentro da função, o valor apontado por x é alterado para 3 e o valor de y é 
atualizado para o valor apontado por x (que agora é 3) mais 1, mas essa atualização não afeta o valor de b 
na função main. Na função main, as variáveis a e b são definidas com valores 1 e 2, respectivamente. A função 
sub é chamada com o endereço de a e o valor de b. Isso significa que dentro da função sub, a referência 
apontada por x aponta para a variável a em main, e qualquer alteração feita nessa referência afetará o valor 
de a em main. Após a chamada da função sub, o valor de z é a soma de a e b, que são 3 e 2, respectivamente. 
Portanto, o valor de z é 5 e a resposta correta é a alternativa c) 5. 
 
Gabarito: Letra C 
 
11. (IBFC – DPE-MT – 2022) Quanto às principais características das linguagens: Java, C e C++, analise as 
afirmativas abaixo e dê valores Verdadeiro (V) ou Falso (F). 
 
( ) A maioria dos códigos escritos em C pode ser compilada em C++. 
 
( ) A linguagem C é considerada como tipicamente orientada a objetos. 
 
( ) As IDE's Eclipse e NetBeans não comportam o desenvolvimento em Java. 
 
Assinale a alternativa que apresenta a sequência correta de cima para baixo: 
 
a) V - F - F 
b) V - V - F 
c) F - V - V 
d) F - F - V 
 
Comentários: 
 
A resposta correta é a alternativa A) V - F - F. (V) A maioria dos códigos escritos em C pode ser compilada em 
C++. C++ é uma extensão da linguagem C, então a maioria dos códigos escritos em C pode ser compilada em 
C++ sem problemas. No entanto, nem todos os recursos de C são suportados em C++, e há diferenças 
importantes na sintaxe e na semântica. (F) A linguagem C é considerada como tipicamente orientada a 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
129
180
 
 
 
objetos. A linguagem C não é tipicamente orientada a objetos. C é uma linguagem procedural que não 
fornece suporte nativo para recursos de orientação a objetos, embora possa ser estendida por meio de 
bibliotecas externas, como o GObject. (F) As IDE's Eclipse e NetBeans não comportam o desenvolvimento 
em Java. Tanto o Eclipse quanto o NetBeans são IDEs populares que suportam o desenvolvimento em Java. 
Na verdade, eles são frequentemente usados para desenvolver aplicativos Java, além de outras linguagens. 
 
Gabarito: Letra A 
 
12. (FCC – TRT - 23ª REGIÃO (MT) – 2022) Considere o programa em C abaixo. 
 
#include <stdio.h> 
 int main() { 
 int y, *p, x; 
 y = 0; 
 p = &y; 
 x = *p; 
 x += 10; 
 ++ (*p); 
 --x; 
 (*p) += x; 
 printf ("y = %i\n", y); 
 return 0; 
} 
 
Ao ser compilado e executado em condições ideais, a saída do programa é: 
 
a) y = 9 
b) y = 0 
c) y = 10 
d) y = 1 
e) y = 11 
 
Comentários: 
 
A saída do programa será "y = 10". O programa começa definindo três variáveis: um inteiro y, um ponteiro 
para inteiro p e um inteiro x. y é inicializado como 0 e p é inicializado como o endereço de y. O programa 
então define x como o valor apontado por p, que é 0. x é então incrementado em 10, tornando-se 10. Em 
seguida, o valor apontado por p é incrementado em 1, tornando-se 1. Depois, x é decrementado em 1, 
tornando-se 9. Por fim, o valor apontado por p é incrementado em x, que é 9. Como resultado, o valor final 
de y é 10. Portanto, a resposta correta é a alternativa c) y = 10. 
Gabarito: Letra C 
 
13. (UFAM – UFAM – 2022) Considere o programa a seguir, elaborado na linguagem ANSI C: 
#include <stdio.h> 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
130
180
 
 
 
int main() { 
 int i, j; 
 for (i = 0; i < 2; i++) { 
 for (j = 1; j < 3; j++) { 
 printf("Teste\n"); 
 } 
 } 
 return 0; 
} 
 
 
Assinale a opção CORRETA sobre o número de vezes que a palavra "Teste" será mostrada, ao 
executarmos o programa: 
 
a) 3 
b) 4 
c) 5 
d) 6 
e) 7 
 
Comentários: 
 
O programa irá imprimir a palavra "Teste" quatro vezes. O primeiro loop for percorre duas vezes, enquanto 
o segundo loop for percorre duas vezes a cada iteração do primeiro loop. Portanto, a palavra "Teste" será 
impressa um total de quatro vezes. Portanto, a resposta correta é a alternativa b) 4. 
Gabarito: Letra B 
 
14. (UFAM – UFAM – 2022) Considere o programa a seguir, elaborado na linguagem ANSI C: 
 
#include <stdio.h> 
 
int* pa; 
int a; 
 
int main() { 
 a = 10; 
 pa = &a; 
 a = 8; 
 printf("%d", a); 
 printf(" %d", *pa); 
 return 0; 
} 
 
Assinale a alternativa CORRETA sobre a saída (output) obtida, ao se executar o programa: 
a) 8 8 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
131
180
 
 
 
b) 10 8 
c) 8 10 
d) 10 10 
e) 9 10 
 
Comentários: 
 
O programa começa por incluir a biblioteca padrão de entrada e saída (stdio.h). Em seguida, define as 
variáveis pa e a. pa é um ponteiro para inteiro (int*) e a é uma variável inteira. Dentro da função main(), o 
programa atribui o valor 10 para a variável a. Em seguida, o endereço de a é atribuído a pa. Depois, o valor 
de a é alterado para 8. Finalmente, o programa imprime o valor de a e o valor apontado por pa (que também 
é 8), separados por um espaço. Assim, a saída do programa será: 8 8. Portanto, a alternativa correta é a letra 
"a". 
Gabarito: Letra A 
 
15. (UFMG – UFMG – 2021) Na linguagem C, foi declarada uma matriz: int matriz[5][6];. 
 
O código abaixo é utilizado para imprimir todos os elementos da matriz. 
 
for (int i = 0; i <= 4; i++) { 
 for (int j = 0; j <= 5; j++) { 
 printf("%d ", matriz[i][j]); 
 } 
} 
 
Qual deve ser os valores de a, b, c e d, respectivamente, para imprimir todos os elementos da matriz? 
 
a) 0; 4; 0; 5. 
b) 1; 4; 1; 5. 
c) 1; 5; 1; 6. 
d) 1; 6; 1; 5. 
 
Comentários: 
 
O código apresentado está correto emrelação à sua sintaxe, mas falta contexto para saber se ele está 
adequado ao objetivo desejado. A estrutura for é utilizada para percorrer os elementos de uma matriz, onde 
a e b representam os limites das linhas a serem percorridas e c e d representam os limites das colunas a 
serem percorridas. Dentro do loop, o programa imprime o valor do elemento presente na posição i da linha 
e j da coluna da matriz. Como a matriz tem dimensões de 5 linhas e 6 colunas, os valores de índices válidos 
para a matriz serão de 0 a 4 para as linhas e de 0 a 5 para as colunas. Portanto, para imprimir todos os 
elementos da matriz, podemos utilizar os valores: a = 0 (primeira linha), b = 4 (última linha), c = 0 (primeira 
coluna), d = 5 (última coluna) 
 
Gabarito: Letra A 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
132
180
 
 
 
16. (UFMG – UFMG – 2021) Considerando o código escrito na linguagem C: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() { 
 int a; 
 int b = 4; 
 a = b++; 
 printf("a=%d e b=%d\n", a, b); 
 return 0; 
} 
 
Qual é o resultado da execução do código? 
 
a) a=4 e b=4 
b) a=4 e b=5 
c) a=5 e b=4 
d) a=5 e b=5 
 
Comentários: 
 
O resultado da execução do código é a=4 e b=5. Isso acontece porque a expressão "b++" primeiro atribui o 
valor atual de "b" para "a" (que fica com valor 4), e depois incrementa o valor de "b" para 5. Então, ao 
imprimir os valores de "a" e "b" no printf, teremos a=4 e b=5. 
Gabarito: Letra B 
 
17. (UFMG – UFMG – 2021) Considerando o código escrito na linguagem C: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
void ops(int *a, int b){ 
 *a = 4; 
 b = *a + 2; 
} 
 
int main() { 
 int x, y, total; 
 x = 1; 
 y = 2; 
 ops(&x,y); 
 total = x + y; 
 printf("%d",total); 
 return 0; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
133
180
 
 
 
} 
 
 
Qual é o valor da variável total que será impresso na saída padrão? 
 
a) 4 
b) 6 
c) 7 
d) 10 
 
Comentários: 
 
O valor da variável x é alterado para 4 pela função ops() e o valor da variável y permanece 2. O programa 
começa com a declaração da função ops, que recebe um ponteiro para inteiro a e um inteiro b. Dentro da 
função, o valor apontado por a é alterado para 4, e o valor de b é modificado para a soma de *a (valor 
apontado por a) mais 2. Como a função ops foi chamada com x passado por referência, a variável x é alterada 
para 4 e y permanece com o valor 2. Na sequência, o valor de total é a soma de x com y, que resulta em 6. 
Esse valor é impresso na tela com o comando printf. Portanto, a alternativa correta é a letra B: 6. 
 
Gabarito: Letra B 
 
18. (CETAP – SEPLAD - PA – 2021) Considere o seguinte programa exemplo escrito em linguagem C e marque 
a alternativa correta. 
 
#include <stdio.h> 
 
int soma(int n) { 
 if(n == 1) 
 return 1; 
 else 
 return (n + soma(n-1)); 
} 
 
int main() { 
 int n; 
 printf("Digite um inteiro positivo: "); 
 scanf("%d", &n); 
 printf("Soma: %d\n", soma(n)); 
 return 0; 
} 
 
(*) fonte do programa retirado de https:/Awww.cprogressivo.net/ acessado em 09/09/2021. 
 
a) O programa exemplo mostra o uso do método de iteração. 
b) O programa exemplo mostra o uso do método de ordenação. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
134
180
 
 
 
c)O programa exemplo mostra o uso do método de passagem de parâmetro. 
d) O programa exemplo mostra o uso do método de recursão. 
 
Comentários: 
 
Gabarito: d) O programa exemplo mostra o uso do método de recursão. O programa calcula a soma dos 
números inteiros de 1 até um número n, utilizando a técnica de recursão. A função soma() é chamada 
recursivamente até que o valor de n seja igual a 1, quando a função retorna 1. Em seguida, as chamadas 
recursivas da função são finalizadas, e os valores de n são somados em cada retorno da função, resultando 
na soma total dos números inteiros de 1 até n. 
Gabarito: Letra D 
 
19. (Instituto UniFil – Prefeitura de Marechal Cândido Rondon - PR – 2021) Linguagem compilada é uma 
linguagem de programação em que o código fonte, nessa linguagem, é executado diretamente pelo 
sistema operacional ou pelo processador, após ser traduzido por meio de um processo chamado 
compilação, usando um programa de computador chamado compilador, para uma linguagem de baixo 
nível, como linguagem de montagem ou código de máquina. Assinale a alternativa que representa 
somente linguagens que são compiladas. 
 
a) Cobol, PHP, C e Python 
b) Cobol, C, Delphi e PHP 
c) Cobol, C, Delphi e C++ 
d) Delphi, C, PHP e Python 
 
Comentários: 
 
A) Cobol, PHP, C e Python: Cobol: é uma linguagem compilada, utilizada principalmente em sistemas 
corporativos e financeiros. PHP: é uma linguagem interpretada, mas é possível compilar o código PHP 
utilizando o Zend Engine, o que faz com que o código seja executado mais rapidamente. C: é uma linguagem 
compilada, amplamente utilizada em sistemas operacionais, drivers de dispositivos, jogos, entre outros. 
Python: é uma linguagem interpretada, mas é possível utilizar ferramentas como o PyInstaller e o PyOxidizer 
para compilar o código Python em um executável. B) Cobol, C, Delphi e PHP: Cobol e C: já explicados 
anteriormente. Delphi: é uma linguagem compilada, utilizada para desenvolvimento de aplicativos para 
desktop, servidores e aplicações móveis. PHP: já explicado anteriormente. C) Cobol, C, Delphi e C++: Cobol, 
C e Delphi: já explicados anteriormente. C++: é uma linguagem compilada, derivada do C e utilizada 
principalmente no desenvolvimento de jogos, sistemas embarcados e software de alta performance. D) 
Delphi, C, PHP e Python: Delphi, C e PHP: já explicados anteriormente. Python: já explicado anteriormente. 
O gabarito é a letra C, pois todas as linguagens mencionadas são linguagens compiladas, ou seja, o código 
fonte é traduzido em código de máquina antes da execução. COBOL, C, Delphi e C++ são exemplos clássicos 
de linguagens compiladas, onde o compilador é responsável por gerar o arquivo executável diretamente a 
partir do código fonte. Por outro lado, as linguagens interpretadas, como Python e PHP, não precisam de um 
processo de compilação antes da execução do código, pois o interpretador pode executar diretamente o 
código fonte linha por linha. Portanto, a alternativa A está incorreta por incluir linguagens interpretadas, 
enquanto as alternativas B e D estão incorretas por não incluírem a linguagem C++, que também é uma 
linguagem compilada. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
135
180
 
 
 
 
Gabarito: Letra C 
 
20. (IDIB – CRECI-PE - 7ª Região – 2021) Qual será a saída do seguinte código C? 
 
#include <stdio.h> 
int main() { 
 int ary[4] = {1, 2, 3, 4}; 
 printf("%d\n", *ary); 
 return 0; 
} 
 
a) 1. 
b) Erro de tempo de compilação (run time error). 
c) Algum valor de lixo. 
d) Variável indefinida. 
 
Comentários: 
 
O código declara um array de inteiros com 4 elementos e inicializa com os valores 1, 2, 3 e 4. Em seguida, é 
impresso na saída padrão o valor do primeiro elemento do array utilizando o operador de desreferência 
(*ary). Como o primeiro elemento doarray é 1, a resposta correta é a alternativa A: "1". Não há erros de 
compilação ou de tempo de execução no código. 
 
Gabarito: Letra A 
 
21. (UFMT – UFMT – 2021) A linguagem de programação C é de propósito geral, sendo caracterizada como 
procedural e imperativa, desenvolvida em 1972 por Dennis M. Ritchie, baseando-se na sua experiência 
com o sistema operacional UNIX. Sua versatilidade e portabilidade lhe garantiram longa vida, sendo 
utilizada hoje também em programação de sistemas embarcados. A linguagem C foi formalizada com o 
ISO/IEC 9899:1990. Analise o código do programa a seguir conforme as definições da linguagem C. 
 
#include <stdio.h> 
 
int um_de_dois(int num1, int num2); 
 
int main() { 
 int a = 100; // definição de variáveis locais 
 int b = 20; 
 int ret_um; 
 ret_um = um_de_dois(a, b); // chamada da função 
 printf("O valor é: %d\n", ret_um); 
 return 0; 
} 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
136
180
 
 
 
int um_de_dois(int num1, int num2) { 
 int result; // declaração de variáveis locais 
 if (num1 > num2) 
 result = num1; 
 else 
 result = num2; 
 return result; 
} 
 
Sobre esse código, marque V para as afirmativas verdadeiras e F para as falsas. 
( ) A execução do programa produz como saída: O valor é: 20. 
( ) A formatação da saída poderia ser feita sem erro com o comando: printf( "O valor é: %f\n", ret_um ); 
( ) A passagem de parâmetros para a função é por valor, pois a função um_de_dois(int num1, int num2) 
não altera o valor da variáveis int a ou int b. 
( ) Os parâmetros formais são os argumentos da função um_de_dois(int num1, int num2), declarados 
como variáveis que aceitam os argumentos da chamada da função um_de_dois(a, b). 
 
Assinale a sequência correta. 
 
a) F, V, F, V 
b) V, V, F, F 
c) V, F, V, F 
d) F, F, V, V 
 
Comentários: 
 
A primeira afirmativa é falsa, pois a execução do programa produz como saída: O valor é: 100. A segunda 
afirmativa é falsa, pois o tipo de dado da variável ret_um é int e não float. A terceira afirmativa é verdadeira, 
pois a passagem de parâmetros para a função em C é por valor, ou seja, a função recebe cópias dos valores 
das variáveis passadas como argumentos. A quarta afirmativa é verdadeira, pois os parâmetros formais são 
os argumentos da função, e na chamada da função, os valores das variáveis a e b são passados como 
argumentos. 
Gabarito: Letra D 
 
22. (CEPUERJ – UERJ – 2021) Um tipo de dados define uma coleção de valores de dados e um conjunto de 
operações pré-definidas sobre ele. O sistema de tipos de uma linguagem de programação define como 
um tipo é associado com cada expressão na linguagem e inclui suas regras para equivalência e 
compatibilidade de tipos. Entender seu sistema de tipos é uma das partes mais importantes para 
entender a semântica de uma linguagem de programação. De acordo com essa afirmação e com os 
conceitos da linguagem de programação Java, é correto afirmar que: 
 
a) o tipo de dado matriz é um agregado homogêneo de elementos de dados no qual um elemento 
individual é identificado por sua posição na agregação. Na linguagem Java, os elementos de uma matriz 
não precisam ser do mesmo tipo 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
137
180
 
 
 
b) a enumeração é um tipo de dado ordinal definido pelo usuário e fornece uma maneira de declarar e 
agrupar coleções de constantes nomeadas 
c) um ponteiro em Java é um tipo de dado em que as variáveis têm uma faixa de valores que consistem 
em endereços de memória 
d) a herança múltipla na linguagem Java segue o mesmo formato e comportamento da linguagem C++ 
 
Comentários: 
 
a) Essa afirmação não é correta para a linguagem de programação Java. Em Java, uma matriz é um tipo de 
dado homogêneo que contém elementos do mesmo tipo. Além disso, a declaração de uma matriz em Java 
requer que seu tamanho seja especificado no momento da declaração. b) Essa afirmação é correta. A 
enumeração em Java é um tipo de dado ordinal que permite declarar e agrupar constantes nomeadas. Por 
exemplo, podemos definir uma enumeração "DiasDaSemana" com as constantes "SEGUNDA", "TERÇA", 
"QUARTA", "QUINTA", "SEXTA", "SÁBADO" e "DOMINGO". c) Essa afirmação não é correta para a linguagem 
de programação Java. Em Java, não existem ponteiros como na linguagem C ou C++. Em vez disso, as 
referências de objetos são usadas para se referir a objetos alocados dinamicamente na memória. Essas 
referências não contêm endereços de memória diretos, mas sim apontam para objetos alocados na 
memória. d) Essa afirmação não é correta. A linguagem Java não suporta herança múltipla direta de classes, 
embora possa ser simulada usando interfaces. Já na linguagem C++, a herança múltipla é suportada 
diretamente. Portanto, a herança múltipla na linguagem Java é diferente do formato e comportamento da 
linguagem C++. 
 
Gabarito: Letra B 
 
23. (INSTITUTO AOCP – ITEP - RN – 2021) Analise o código C++ a seguir: 
 
#include <iostream> 
using namespace std; 
 
void meuNome(string nome, int idade) { 
cout << "Seu nome é " << nome << " e sua idade é " << idade << endl; 
} 
 
int main() { 
string nome; 
int idade; 
cout << "Digite seu nome: "; 
cin >> nome; 
cout << "Digite sua idade: "; 
cin >> idade; 
meuNome(nome, idade); 
return 0; 
} 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
138
180
==30e709==
 
 
 
Para que a chamada da função meuNome, ocorra livre de erros, assinale a alternativa correta em relação 
à escrita dessa função. 
 
a) void meuNome(string Nome, int Idade) { cout << "Meu nome é "<< Nome << ". Tenho " << Idade << " 
anos.\n"; } 
b) meuNome(string nome, int idade) { cout << "Meu nome é "<< nome << ". Tenho " << idade << " 
anos.\n"; } 
c) void meuNome(nome, idade) { cout << "Meu nome é "<< nome << ". Tenho " << idade << " anos.\n"; } 
d) meuNome() { cout << "Meu nome é "<< nome << ". Tenho " << idade << " anos.\n"; } 
e) void meuNome(nome, idade) { cout << "Meu nome é %s.", nome; cout << "Tenho %d anos.", idade; } 
 
Comentários: 
 
A função meuNome deve receber dois argumentos, uma string para o nome e um inteiro para a idade, 
conforme definido na declaração da função. Na alternativa a), os nomes dos parâmetros da função estão 
corretos e a mensagem de saída está de acordo com a esperada no código original. Nas demais alternativas, 
há erros de sintaxe ou semântica que impedem a compilação ou o correto funcionamento do programa. 
 
Gabarito: Letra A 
 
24. (INSTITUTO AOCP – ITEP - RN – 2021) Em linguagens de programação, os tipos de dados podem ser 
classificados como elementares ou estruturados. Em qual das alternativas a seguir há exemplos somente 
de um mesmo tipo de dado (elementar ou estruturado) reconhecido pela linguagem C++? 
 
a) Struct e array. 
b) Integer e class. 
c) Float e class. 
d) Char e union. 
e) Enum e struct. 
 
Comentários: 
 
Uma struct é um tipo de dado definido pelo usuário que permite agrupar diferentes variáveis sob um único 
nome. É uma coleção de variáveis de tipos diferentes, que são acessadas por meio de um identificador 
comum. Um array é uma coleção de elementos de um mesmo tipo de dados, que é armazenada em uma 
sequência contígua de memória. Cada elemento pode ser acessado por meio de um índice. Integer é um tipo 
de dado primitivo que armazena valores numéricos inteiros. Em C++, ele é representado pelo tipo"int". Class 
é um tipo de dado definido pelo usuário que permite criar uma abstração de dados. É uma estrutura que 
encapsula dados e comportamentos relacionados a esses dados em uma única entidade. Uma classe pode 
conter variáveis, funções e métodos. Float é um tipo de dado primitivo que armazena valores numéricos em 
ponto flutuante. Em C++, ele é representado pelo tipo "float". Char é um tipo de dado primitivo que 
armazena um único caractere. Em C++, ele é representado pelo tipo "char". Union é um tipo de dado definido 
pelo usuário que permite que diferentes tipos de dados compartilhem o mesmo espaço de memória. A ideia 
é que apenas um dos tipos esteja ativo em um determinado momento e o acesso aos dados da union deve 
ser feito de forma cuidadosa para evitar comportamentos inesperados. Por fim, Enum é um tipo de dado 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
139
180
 
 
 
definido pelo usuário que permite definir um conjunto de constantes nomeadas. As constantes são 
atribuídas a valores inteiros sequenciais, a partir de um valor inicial especificado. A opção que apresenta 
exemplos somente de um mesmo tipo de dado (elementar ou estruturado) reconhecido pela linguagem C++ 
é a alternativa A) Struct e array. 
 
 
Gabarito: Letra A 
 
25. (INSTITUTO AOCP – ITEP - RN – 2021) Em relação às características da linguagem C, assinale a alternativa 
correta. 
 
a) É uma linguagem interpretada. 
b) Não possui tratamento de exceções. 
c) Possui 64 palavras reservadas. 
d) Suporta orientação a objeto. 
e) Os tipos básicos de variáveis para manipulação de caracteres são o char e string. 
 
Comentários: 
 
Vamos analisar cada alternativa: a) É uma linguagem interpretada. Esta afirmação é incorreta. C é uma 
linguagem compilada, o que significa que o código-fonte é transformado em código objeto por meio de um 
compilador antes de ser executado. b) Não possui tratamento de exceções. Esta afirmação é verdadeira. A 
linguagem C não possui mecanismos de tratamento de exceções nativamente, o que pode tornar o código 
propenso a erros inesperados em tempo de execução. c) Possui 64 palavras reservadas. Esta afirmação é 
incorreta. A linguagem C possui um número limitado de palavras-chave reservadas, que podem variar de 
acordo com a implementação do compilador. Por exemplo, o padrão C99 especifica apenas 32 palavras-
chave reservadas. d) Suporta orientação a objeto. Esta afirmação é parcialmente verdadeira. Embora a 
linguagem C não tenha recursos de orientação a objeto integrados, é possível implementar conceitos de 
programação orientada a objetos em C usando técnicas como estruturas e ponteiros de função. e) Os tipos 
básicos de variáveis para manipulação de caracteres são o char e string. Esta afirmação é incorreta. O tipo 
básico para manipulação de caracteres em C é o char, enquanto a string é uma sequência de caracteres 
terminada por um caractere nulo ('\0') e é implementada como um array de chars. 
 
Gabarito: Letra B 
 
26. (FADESP – Câmara de Marabá - PA – 2021) Considerando o operador de pós-incremento, utilizado na 
linguagem C, o resultado da execução do código é: 
 
#include <stdio.h> 
#include <stdlib.h> 
 
int main() { 
 int y, x = 10; 
 y = x++; 
 printf("x = %d\n", x); 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
140
180
 
 
 
 printf("y = %d\n", y); 
 system("pause"); 
 return 0; 
} 
 
a) x = 10 e y = 10. 
b) x = 11 e y = 11. 
c) x = 10 e y = 11. 
d) x = 11 e y = 10. 
e) x = 11 e y = 0. 
 
Comentários: 
 
O operador de pós-incremento (++) incrementa o valor de uma variável após o uso dessa variável em uma 
expressão. No código fornecido, o valor de x é atribuído a y antes de ser incrementado.Assim, a expressão y 
= x++ é avaliada da seguinte maneira: A variável y recebe o valor de x, que é 10. O operador de pós-
incremento é aplicado em x, fazendo com que o seu valor seja incrementado em 1, passando a ser 11. 
Portanto, no final da execução, o valor de x é 11 e o valor de y é 10. A alternativa correta é a letra d). 
 
Gabarito: Letra D 
 
27. (IBFC – IBGE – 2021) Quanto às linguagens de programação, assinale a alternativa que esteja 
tecnicamente incorreta. 
 
a) Java é uma das principais representantes das linguagens orientadas a objetos 
b) JavaScript, é uma sub-línguagem do Java, feita para o desenvolvimento de aplicações para Android 
c) Grande parte dos sistemas operacionais existentes no mercado foram escritos em C 
d) Assembly é uma linguagem de programação de baixo nível, também definida, muitas vezes, como 
linguagem de montagem 
e) A linguagem de programação C# foi desenvolvida pela Microsoft 
 
Comentários: 
 
A alternativa INCORRETA é a letra B. JavaScript é uma linguagem de programação que permite a você 
implementar itens complexos em páginas web — toda vez que uma página da web faz mais do que 
simplesmente mostrar a você informação estática — mostrando conteúdo que se atualiza em um intervalo 
de tempo, mapas interativos ou gráficos 2D/3D animados, etc. — você pode apostar que o JavaScript 
provavelmente está envolvido. Ademais, vejamos a alternativa C que trata sobre a linguagem C. A alternativa 
C está correta, já que grande parte dos sistemas operacionais foram escritos em C. Na verdade, muitos dos 
principais sistemas operacionais do mercado, como o Unix, o Linux e o Windows, foram criados com o uso 
da linguagem C. A linguagem C é muito popular para programação de sistemas, já que permite um controle 
mais preciso sobre o hardware do computador e é altamente portátil, permitindo que o mesmo código seja 
executado em diferentes sistemas operacionais. Além disso, a linguagem C é bastante eficiente e oferece 
recursos para gerenciamento de memória e acesso a dispositivos de hardware, o que a torna uma escolha 
popular para o desenvolvimento de drivers e outros softwares de baixo nível. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
141
180
 
 
 
 
Gabarito: Letra B 
 
28. (FAFIPA – Prefeitura de Arapongas - PR – 2020) A linguagem de programação C é uma linguagem 
compilada de propósito geral, estruturada, imperativa e procedural. Esta é uma das linguagens de 
programação mais populares e tem influenciado muitas outras linguagens de programação, como por 
exemplo, a linguagem Java. Observe a figura, onde é apresentado um código escrito em C: 
 
#include <stdio.h> 
 
int main() 
{ 
 int i = 3; 
 printf("%d", ++i); 
 return 0; 
} 
 
Após executar o código da figura no Compilador C, o que será apresentado no console? 
 
a) 4. 
b) 3. 
c) 2. 
d) 1. 
e) 0. 
 
Comentários: 
 
O código apresentado é um programa em C que imprime o valor de uma variável "i" na tela, utilizando a 
função "printf" da biblioteca padrão "stdio.h". Inicialmente, é declarada a variável "i" como um inteiro e 
atribuído o valor 3 a ela. Em seguida, a expressão "++i" é utilizada como argumento da função "printf". A 
expressão "++i" é um operador de pré-incremento, que incrementa o valor da variável "i" em 1 e retorna o 
novo valor. Portanto, quando a função "printf" é executada, o valor impresso na tela será 4, que é o valor 
resultante da operação "++i" (3+1). Ao executar o código apresentado, será exibido o valor 4 no console, pois 
o operador de pré-incremento (++i) incrementa o valor da variável i em 1 antes de imprimi-la na tela. Sendo 
assim, o valor de i será 4 no momento da impressão. 
Gabarito:Letra A 
 
29. (FAPEC – UFMS – 2020) Considere o código a seguir, utilizando a linguagem de programação C. Assinale 
a alternativa correta. 
 
#include <stdio.h> 
 
int main() { 
 int x = 1, y, z; 
 y = ++x; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
142
180
 
 
 
 z = y++; 
 y = 2; 
 printf("%%%d, %d, %d%%", x, y, z); 
 return 0; 
} 
 
a) Será impresso: %1, 2, 3%. 
b) Será impresso: 2, 2, 3. 
c) Será impresso: %2, 2, 2%. 
d) Será impresso: 1, 2, 3. 
e) Ocorrerá o seguinte erro: incompatible type for argument 1 of ‘printf’. 
 
Comentários: 
 
O código declara três variáveis inteiras: x, y e z, inicializando apenas x com o valor 1. Em seguida, a variável 
y recebe o valor de x após ser incrementado em 1 (devido ao operador de pré-incremento ++x). Depois, a 
variável z recebe o valor de y antes de ser incrementado (devido ao operador de pós-incremento y++). A 
variável y recebe o valor 2. Em seguida, a variável y é atribuída com o valor 2. Por fim, a função printf() é 
chamada para imprimir o valor de x, y e z, respectivamente, em um formato específico. Como resultado, será 
impresso "%2, 2, 2%" no console. 
 
Gabarito: Letra C 
 
30. (FUCAP – Câmara da Estância Balneária de Praia Grande - SP – 2019) Assinale a única alternativa que 
indica corretamente a principal linguagem de programação usada para escrever o código-fonte das várias 
versões do Windows: 
 
a) Java; 
b) Javascript; 
c) PHP; 
d) C. 
 
Comentários: 
 
A principal linguagem de programação utilizada para escrever o código-fonte do sistema operacional 
Windows é a linguagem de programação C. O Windows é escrito em grande parte em C, embora também 
seja utilizada a linguagem Assembly para algumas partes críticas do sistema. 
 
Gabarito: Letra D 
 
31. (UFAM – UFAM – 2019) Considere o programa na linguagem C: 
 
#include <stdio.h> 
 
int main() { 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
143
180
 
 
 
 int array[10] = {1, -2, 3, -4}; 
 int a, loop; 
 a = 0; 
 for (loop = 1; loop >= 0; loop--) { 
 a = a + array[loop]; 
 } 
 printf(" %d", a); 
 return 0; 
} 
 
Ao executarmos o programa, o valor da saída será: 
 
a) −1 
b) 1 
c) −2 
d) 2 
e) 3 
 
Comentários: 
 
O programa declara um array de inteiros chamado array com tamanho 10, mas apenas os quatro primeiros 
elementos são inicializados. Em seguida, ele inicializa a variável a como zero e entra em um loop for que 
começa com a variável loop igual a 1 e decrementa até 0. Dentro do loop, a variável a é atualizada 
adicionando o valor do elemento array[loop]. Na primeira iteração do loop, loop é 1 e array[1] é -2, então a 
é atualizada para -2. Na segunda iteração do loop, loop é 0 e array[0] é 1, então a é atualizada para -1. Por 
fim, o programa imprime o valor de a, que é -1. Portanto, a resposta correta é a letra A) −1. 
 
Gabarito: Letra A 
 
32. (UFAM – UFAM – 2019) Considere o programa na linguagem C: 
 
#include <stdio.h> 
 int main(){ 
 int a, b, c; 
 printf("Digite dois números\n"); 
 scanf("%d%d", &a, &b); 
 c = a; 
 a = b; 
 b = a; 
 printf("%d %d\n", a, b); 
 return 0; 
 } 
 
Executando e digitando como entrada os números 12 e 14, a saída será: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
144
180
 
 
 
a) 12 14 
b) 12 12 
c) 14 14 
d) 14 12 
e) 26 
 
Comentários: 
 
A variável b é atribuída para a, e em seguida a variável a é atribuída novamente para b, o que acaba deixando 
ambas com o mesmo valor original. Portanto, a saída será 14 14, correspondente às variáveis a e b, 
respectivamente. A alternativa correta é a letra c). 
 
Gabarito: Letra C 
 
33. (FURB – Prefeitura de Porto Belo - SC – 2019) Leve em consideração o código abaixo, em linguagem C: 
 
#include <stdio.h> 
 
int a(int b) { 
 if (b <= 1) { 
 return 1; 
 } 
 return b * a(b - 1) - 1; 
} 
 
void main() { 
 int b = a(5), d = 0, c = 1, e = 43; 
 while (1) { 
 d = 1; 
 c += 2; 
 b -= 7; 
 if ((c + e + d + b) <= 44) { 
 printf("%d\n", c); 
 break; 
 } 
 d = a(d); 
 e -= c; 
 } 
 printf("%d\n", e); 
 printf("%d", b); 
} 
 
Os valores impressos na tela serão, respectivamente: 
 
a) 9, 28, 6. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
145
180
 
 
 
b) 3, 43, 27. 
c) 19, -37, 27. 
d) 11, 19, -1. 
e) 3, 43, 0. 
 
Comentários: 
 
O programa irá imprimir os valores 3, 43 e 27. A função "a(int b)" é uma função recursiva que calcula o 
fatorial de um número, mas com a particularidade de subtrair 1 do resultado final. Neste caso, a chamada 
"a(5)" retorna o valor 119, que é atribuído à variável "b". Dentro do laço "while", a variável "c" é 
incrementada em 2 a cada iteração, a variável "b" é decrementada em 7, e a variável "d" é atribuída o valor 
1. O resultado da expressão "(c + e + d + b) <= 44" é verdadeiro quando "c" vale 3, "e" vale 43, "d" vale 1 e 
"b" vale 27, o que faz o programa entrar no "if" e imprimir o valor de "c" (3) e sair do laço com "break". 
Depois disso, o programa imprime o valor de "e" (43) e o valor de "b" (que agora vale 27). 
 
Gabarito: Letra B 
 
34. (IBADE – Prefeitura de Vilhena - RO – 2019) Dado o código abaixo, escrito em linguagem de programação 
C, o que seria impresso na tela se fosse compilado e executado? 
 
int main(){ 
 int i, j, k=1, mat[4][4]; 
 for(i=0; i<4; i++) 
 for(j=0; j<4; j++){ 
 mat[i][j]=k; 
 k++; 
 } 
 
 for(i=0; i<4; i++) 
 for(j=2; j<4; j++) 
 if(i%j == 0) 
 printf("%d; ",mat[j][i]); 
 return 0; 
} 
 
a) 1; 3; 5; 7; 11 
b) 3; 6; 9; 12; 15 
c) 9; 13; 11; 16 
d) 1; 5; 10; 15 
e) 10 
 
Comentários: 
 
O código acima apresenta um programa em linguagem de programação C. O programa cria uma matriz de 
inteiros de tamanho 4x4 e preenche cada elemento com um valor sequencial a partir de 1. Em seguida, é 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
146
180
 
 
 
feita uma verificação em um laço de repetição em que, se a variável i for divisível por j, onde j é um valor 
entre 2 e 3, é impresso o valor do elemento da matriz correspondente à linha j e coluna i. Como i varia de 0 
a 3 e só é impresso o valor do elemento da matriz quando i é divisível por j (sendo j um número primo), 
apenas alguns elementos da matriz serão impressos. Neste caso, serão impressos os valores 9, 13, 11 e 16. 
Portanto, a resposta correta é a alternativa c) 9; 13; 11; 16. 
Gabarito: Letra C 
 
35. (IDECAN – UNIVASF – 2019) Dado o seguinte código fonte na linguagem C: 
 
#include <stdio.h> 
#include <unistd.h> 
 
int main() { 
 int i; 
 for (i = 0; i < 4; i++) { 
 if (i % 2 == 0) { 
 fork(); 
 } 
 } 
 return 0; 
} 
Assinale a alternativa que indica corretamente, incluindo o processo pai inicial, quantos processos são 
criados pelo programa mostrado no código após compilação com ocompilador GCC e execução na linha 
de comando. 
 
a) 5 
b) 4 
c) 3 
d) 2 
e )1 
 
 
Comentários: 
 
O código em questão cria processos filhos a partir de um processo pai utilizando a função fork(), que cria um 
novo processo. No loop for, a cada iteração, é verificado se i é um número par, caso seja, é chamada a função 
fork(), criando um novo processo filho que passa a ser executado em paralelo com o processo pai. O número 
de processos criados depende do número de iterações do loop e das condições definidas dentro do mesmo. 
Neste caso, são criados 4 processos (incluindo o processo pai inicial), já que o loop executa 4 vezes e a 
condição para criar um processo é que o valor de i seja par. 
 
Caso queira uma explicação mais detalhada, siga em frente, se já entendeu de forma suficiente, vá para a 
próxima questão. Quer entender mais? Então vamos lá: Ao iniciar a execução do programa, a variável i é 
inicializada com 0 e, em seguida, o loop é executado quatro vezes. Na primeira iteração, o valor de i é 0 e o 
resultado da expressão i % 2 é 0, portanto, o processo pai cria um novo processo filho usando a função fork(). 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
147
180
 
 
 
Esse novo processo filho também continua a executar o mesmo loop for. Na segunda iteração, o valor de i é 
1 e o resultado de i % 2 é 1, então o processo pai não cria um novo processo filho. No entanto, o processo 
filho criado na primeira iteração continua a executar o mesmo loop for. Na terceira iteração, o valor de i é 2 
e o resultado de i % 2 é 0, portanto, tanto o processo pai quanto o processo filho criado na primeira iteração 
criam um novo processo filho cada usando a função fork(). Ambos os processos filhos criados também 
executam o mesmo loop for. Na última iteração, o valor de i é 3 e o resultado de i % 2 é 1, portanto, o 
processo pai e o processo filho criado na segunda iteração não criam um novo processo filho. O primeiro 
processo filho criado na primeira iteração cria um novo processo filho e continua a executar o loop for, 
enquanto os outros dois processos filhos criados na terceira iteração executam o loop for. Assim, no final, 
serão criados 4 processos filhos em total, cada um executando o loop for a partir do ponto em que foi criado. 
 
Gabarito: Letra B 
 
36. (FCC – TRF - 3ª REGIÃO – 2019) Em C++, a chamada de uma função provoca o desvio do controle de 
execução para o início do código da função. Quando do seu término, o controle de execução volta para 
a instrução seguinte à sua chamada. Funções poupam espaço de memória, mas requerem mais tempo 
de execução. Se houver uma função muito pequena em relação à quantidade de instruções, em seu lugar 
utiliza-se 
 
a) DO WHILE. 
b) INCLUDE. 
c) PERFORM 
d) INLINE. 
e) DO UNTIL. 
 
 
Comentários: 
 
Em C++, se uma função for muito pequena em relação à quantidade de instruções, pode-se utilizar a diretiva 
inline para indicar ao compilador que o código da função deve ser "inserido" diretamente no local em que a 
função é chamada, evitando assim a sobrecarga de chamada de função e aumentando o desempenho do 
programa. A opção correta é a letra D. 
 
Gabarito: Letra D 
 
37. (COMPERVE – UFRN – 2019) O chefe do departamento de TI da Security10 enviou para João, por e-mail, 
o programa simples em linguagem C, mostrado abaixo, com intuito de aferir os conhecimentos do novo 
contratado sobre segurança de software. 
 
L1. void LerParametros (char *arg); 
L2. void main (int argc, char *argv[]) { 
L3. if (arg > 1){ 
L4. printf ("Parametros informados: %s\n", argv[1]); 
L5. LerParametros (argv[1]); 
L6. } 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
148
180
 
 
 
L7. } 
L8. void LerParametros (char *arg) { 
L9. char buffer[10]; 
10. strcpy (buffer, arg); 
L11. printf (buffer); 
L12. } 
 
 
Junto ao código, estava a mensagem: “João, por favor, verifique esse código. Sei que estamos fazendo 
algo errado e, com isso, expondo uma vulnerabilidade de segurança comum em programação, mas não 
consigo perceber qual. Falamos mais sobre isso na segunda”. João, ao analisar o código enviado, concluiu 
que esse apresenta como vulnerabilidade 
 
a) uma Falha de Segmentação (do inglês, Segmentation Fault) na linha L5. 
b) uma Falha de Segmentação (do inglês, Segmentation Fault) na linha L4. 
c) um Estouro de buffer (do inglês, Buffer Overflow) na linha L9. 
d) um Estouro de buffer (do inglês, Buffer Overflow) na linha L10. 
 
Comentários: 
 
A vulnerabilidade presente no código é o Estouro de buffer (Buffer Overflow) na linha L10. Isso ocorre porque 
a função strcpy() copia a string de argumento para o buffer sem verificar se a string cabe no buffer. Se a 
string de argumento for maior que o buffer (no caso, 10 caracteres), haverá um estouro de buffer e o 
comportamento do programa se torna indefinido, podendo levar a erros de segmentação, execução de 
código malicioso e outros problemas de segurança. Para corrigir essa vulnerabilidade, é necessário verificar 
o tamanho da string de argumento antes de copiá-la para o buffer. Uma solução seria usar a função strncpy(), 
que permite definir o tamanho máximo de cópia. 
Gabarito: Letra D 
 
38. (IF-MT – IF-MT – 2019) Analise o trecho de código escrito na linguagem C apresentado a seguir: 
 
#include <stdio.h> 
 
int main(void) { 
 int c, *x1, *x2; 
 x1 = &c; 
 x2 = x1; 
 printf("%p\n", x1); 
 printf("%p\n", x2); 
 return 0; 
} 
 
É CORRETO afirmar que: 
 
a) Sua execução apresentará uma mensagem de erro. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
149
180
 
 
 
b) O código possui erros léxicos e sintáticos. 
c) A sua execução apresentará na tela o resultado: %p\nx1 %p\nx2. 
d) A sua execução apresentará dois valores iguais. 
e) A sua execução não apresentará mensagens ou resultados. 
 
Comentários: 
 
O trecho de código apresentado não possui erros léxicos ou sintáticos e sua execução imprimirá na tela dois 
valores iguais, que representam o endereço de memória da variável 'c', que foi atribuído aos ponteiros 'x1' 
e 'x2'. O código apresentado cria três variáveis: um inteiro c, e dois ponteiros para inteiros x1 e x2. Em 
seguida, o ponteiro x1 é inicializado com o endereço de memória da variável c, através do operador "&". O 
ponteiro x2 é atribuído com o valor do ponteiro x1, ou seja, ambos os ponteiros apontam para o mesmo 
endereço de memória. Por fim, são impressos na tela os valores dos ponteiros x1 e x2, utilizando o 
especificador de formato "%p", que imprime o valor do ponteiro como um endereço hexadecimal na 
memória. Como ambos os ponteiros apontam para o mesmo endereço, a impressão dos dois valores será 
igual, resultando na impressão de dois endereços de memória iguais na tela. Caso você tenha alguma dúvida 
em relação ás demais alternativas, vamos analisar cada uma delas. a) A alternativa (a) afirma que a execução 
do código apresentará uma mensagem de erro, o que não é verdade. O código está correto e não apresenta 
nenhum erro durante a sua execução. b) A alternativa (b) afirma que o código possui erros léxicos e 
sintáticos, o que também não é verdade. O código está escrito de forma correta e pode ser compilado sem 
problemas. c) A alternativa (c) afirma que a execução do código apresentará na tela o resultado: %p\nx1 
%p\nx2, o que não é verdade. O código usa a função printf para imprimir o valor dos ponteiros, mas a saídacorreta seria apresentar dois endereços de memória diferentes, e não a string "%p\nx1 %p\nx2". e) A 
alternativa (e) afirma que a execução não apresentará mensagens ou resultados, o que não é verdade. A 
função printf é usada para imprimir os valores dos ponteiros na tela. 
 
Gabarito: Letra D 
 
39. (IF-MT – IF-MT – 2019) Considere o trecho de código escrito na linguagem C apresentado a seguir: 
 
#include <stdio.h> 
 
int MinhaFuncao(int a, int b) { 
 return a/**//b; 
} 
 
int main() { 
 printf("%d", MinhaFuncao (2,3)); 
 return 1; 
} 
 
Assinale a alternativa que apresenta o resultado da sua execução: 
 
a) 1.5 
b) 0.66667 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
150
180
 
 
 
c) 0 
d) 1 
e) 8 
 
Comentários: 
 
O resultado da execução do código apresentado será "0". Isso ocorre porque a função "MinhaFuncao" realiza 
uma divisão entre dois inteiros utilizando o operador "/", que retorna o resultado da divisão inteira. No caso 
em questão, 2 dividido por 3 resulta em 0,66, que arredondado para o inteiro mais próximo resulta em 0. 
Assim, a função retorna 0, que é impresso pelo printf no main. 
 
Gabarito: Letra C 
 
40. (COMPERVE – UFRN – 219) A linguagem de programação C está entre as linguagens de programação 
mais utilizadas para desenvolvimento de bibliotecas e sistemas operacionais pelas suas características de 
portabilidade e desempenho. É uma linguagem baseada em ponteiros que possui diversas formas de 
acesso ao conteúdo da memória. Dada uma matriz A com n colunas armazenada continuamente na 
memória, a lista de expressões que contém formas equivalentes de acesso ao mesmo conteúdo da 
memória é 
 
a) A[i][j], (&A+i*n+j), e A[i*n+j]. 
b) A[i][j], &(A+i*n*j), e A[i*n*j]. 
c) A[i][j], (*A+i*n*j), e A[i*n*j]. 
d) A[i][j], *(A+i*n+j), e A[i*n+j]. 
 
Comentários: 
 
A lista de expressões equivalentes é A[i][j], (A+in+j), e A[in+j]. A primeira expressão A[i][j] é a forma mais 
comum de acesso a um elemento da matriz. A segunda expressão (A+in+j) utiliza aritmética de ponteiros 
para acessar o elemento (i,j) da matriz A. Finalmente, a terceira expressão A[in+j] é uma forma alternativa, 
mas equivalente, de acessar o mesmo elemento usando aritmética de índices. 
 
Gabarito: Letra D 
 
41. (FCC – TRF - 4ª REGIÃO – 2019) As linguagens de programação 
 
a) como Java e C# têm seus códigos fontes transformados em uma linguagem intermediária (específica 
de cada linguagem), que será interpretada pela máquina virtual da linguagem quando o programa for 
executado. 
 
b) como C e Ruby são compiladas estaticamente e seus códigos-fontes são transformados diretamente 
em linguagem de montagem ou assembler. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
151
180
 
 
 
c) do tipo script como VBScript e Lua são utilizadas em aplicações web. No caso de sites do WordPress, 
por exemplo, os desenvolvedores criam plug-ins e usam o VB para solicitar o conteúdo. O código é 
executado como HTML, permitindo que os visitantes do site visualizem o conteúdo em seus navegadores. 
 
d) orientadas a objeto são todas compiladas e não interpretadas, por isso são consideradas de baixo 
nível, sendo as mais utilizadas para programação de sistemas embarcados ou aplicações que exijam 
acesso direto a registros da memória. 
 
e) interpretadas têm seu código-fonte traduzido por um programa tradutor ou assembly, que em seguida 
é executado pelo sistema operacional. Um exemplo disso é o Bytecode, que é uma linguagem que passa 
pelo processo de interpretação e, em seguida, é executada por um compilador. 
 
Comentários: 
 
Linguagens de programação como Java e C# utilizam um processo de compilação em duas etapas, em que o 
código-fonte é primeiro compilado para uma linguagem intermediária (Java bytecode e CIL, 
respectivamente), que é interpretada pela máquina virtual da linguagem quando o programa é executado. 
Esse processo é conhecido como compilação just-in-time (JIT). Essa abordagem oferece várias vantagens, 
como a portabilidade do código-fonte, já que a máquina virtual é executada em diferentes sistemas 
operacionais, e a segurança, já que a máquina virtual isola o programa do sistema operacional hospedeiro. 
Vejamos as demais alternativas. B) Em linguagens de programação como C e Ruby, o código-fonte é 
compilado diretamente para linguagem de máquina ou código de montagem (assembler). Essa abordagem 
é conhecida como compilação estática. O código gerado é específico para a plataforma em que a compilação 
ocorre e, portanto, não é portátil. C) Linguagens de script, como VBScript e Lua, podem ser utilizadas em 
aplicações web, mas o exemplo dado na alternativa não é preciso. Os plugins para o WordPress, por exemplo, 
geralmente são escritos em PHP e não em VBScript. O VBScript é uma linguagem de script da Microsoft que 
é executada em ambientes Windows. Além disso, o código em linguagens de script é interpretado, não 
compilado. D) Linguagens orientadas a objetos, como Java e C++, podem ser compiladas ou interpretadas, 
dependendo da implementação. Elas não são consideradas de baixo nível, já que o paradigma de 
programação orientada a objetos é relativamente alto nível e abstrato. Sistemas embarcados geralmente 
usam linguagens de baixo nível, como C ou Assembly. E) Linguagens interpretadas, como Python e Ruby, são 
traduzidas para código de máquina em tempo de execução por um programa chamado interpretador. O 
bytecode mencionado na alternativa é uma forma intermediária de código gerado por algumas linguagens 
interpretadas, como Java e Python. O bytecode é então interpretado pelo interpretador da linguagem para 
executar o programa. 
 
Gabarito: Letra A 
 
42. (NC-UFPR – ITAIPU BINACIONAL – 2019) Considere o programa abaixo: 
 
Assinale a alternativa que indica corretamente a quantidade de vezes que a palavra “prova” será 
impressa: 
 
#include <stdio.h> 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
152
180
 
 
 
int main() { 
 printf("prova"); 
 main(); 
 return 10; 
} 
 
a) nenhuma. 
b) infinitas vezes. 
c) uma vez. 
d) dez vezes. 
e) será impressa continuamente até que ocorra o estouro da pilha. 
 
Comentários: 
 
A resposta correta é a letra E. O programa apresenta uma chamada recursiva infinita da função main(), o que 
fará com que a string "prova" seja impressa continuamente até que ocorra o estouro da pilha de execução. 
Essa é uma situação conhecida como "stack overflow". O retorno return 10 não será alcançado. 
 
Gabarito: Letra E 
 
43. (NC-UFPR – ITAIPU BINACIONAL – 2019) Um programador escreve o programa abaixo e tenta compilar 
e executar. 
 
#include "stdio.h" 
 
int main() { 
 int i; 
 goto LOOP; 
 for (i = 0; i < 10; i++) { 
 printf("sucesso"); 
 LOOP: break; 
 } 
 return 0; 
} 
 
Assinale a alternativa que indica corretamente o que deve ocorrer: 
 
a) O programa não compila. 
b) O programa compila com sucesso, mas não imprime nada quando executado. 
c) O programa compila com sucesso, e quando executado imprime “sucesso” uma vez. 
d) O programa compila com sucesso, mas apresentará erro de execução. 
e) O programa compila com sucesso, e quando executado imprime “sucesso” dez vezes. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
153
180
 
 
 
O programa compila com sucesso, mas não imprime nada quando executado, pois a instrução goto LOOP 
redireciona a execução do programa para a label LOOP que está logo abaixo, e a instrução break dentro do 
laço de repetição faz com que ele saia imediatamente, sem executar o printf. Portanto, o laço de repetição 
é executado apenas uma vez, e depois o programa é finalizado sem imprimir nada. 
 
Gabarito: Letra B 
 
44. (NC-UFPR – ITAIPU BINACIONAL – 2019) Considere o programa abaixo, escrito em linguagem C: 
 
#include <stdio.h> 
 
int i, j, k; 
 
int main() { 
 for (i = 0, j = 1, k = 2; i < k; i++) { 
 } 
 k = k + i % 2; 
 printf("%d,%d,%d", i, j, k); 
 return 0; 
} 
 
Assinale a alternativa que indica o que será impresso por esse programa. 
 
a) 0, 1, 2 
b) 1, 2, 3 
c) 3, 1, 3 
d) 3, 2, 1 
e) 3, 1, 2 
 
Comentários: 
 
A condição do loop é i<k, e como inicialmente k=2 e i=0, o loop não será executado nenhuma vez. Em seguida, 
k é atualizado para k+i%2, que é igual a 2+0%2, resultando em k=2. Por fim, é impresso o valor de i, j e k, que 
são respectivamente 0, 1 e 3. Portanto, a alternativa correta é a letra C. 
Gabarito: Letra C 
 
45. (IF-SP – IF-SP – 2019) Nas linguagens de programação Java e C++, o polimorfismo paramétrico é 
materializado, respectivamente, pelas funcionalidades e/ou características: 
 
a) Genéricos e Templates. 
b) Genéricos e Sobrecarga de Operadores. 
c) Sobrecarga e Templates. 
d) Anotações e Sobrescrita. 
 
Comentários: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
154
180
 
 
 
 
Vamos analisar cada alternativa: A) Genéricos e Templates: em Java, o polimorfismo paramétrico é 
implementado através do recurso de "genéricos", que permite criar classes e métodos que possam ser 
usados com tipos diferentes de objetos, sem a necessidade de criar várias versões da mesma classe ou 
método. Em C++, o polimorfismo paramétrico é implementado através de "templates", que permitem criar 
classes e funções genéricas que possam ser usadas com diferentes tipos de dados. B) Genéricos e Sobrecarga 
de Operadores: a sobrecarga de operadores permite que um mesmo operador tenha comportamentos 
diferentes dependendo dos tipos de dados que estão sendo usados. Isso permite criar funções genéricas que 
possam ser aplicadas a diferentes tipos de dados. Em Java, a sobrecarga de operadores não é suportada, mas 
os genéricos podem ser usados para criar funções genéricas. Em C++, a sobrecarga de operadores é 
suportada e pode ser combinada com templates para criar funções genéricas que trabalham com diferentes 
tipos de dados. C) Sobrecarga e Templates: a sobrecarga permite criar funções e métodos com o mesmo 
nome, mas com comportamentos diferentes, dependendo dos parâmetros que são passados. Isso permite 
criar funções genéricas que possam ser usadas com diferentes tipos de dados. Em Java, a sobrecarga é 
suportada, mas os genéricos são a principal ferramenta para criar funções genéricas. Em C++, a sobrecarga 
é suportada e pode ser combinada com templates para criar funções genéricas que trabalham com 
diferentes tipos de dados. D) Anotações e Sobrescrita: a sobrescrita (ou "override") é uma técnica que 
permite que uma classe filha substitua um método da classe pai, mantendo o mesmo nome, mas com 
comportamento diferente. Isso não tem relação direta com o polimorfismo paramétrico. Já as anotações são 
utilizadas em Java para adicionar metadados a classes e métodos, o que pode ser útil em alguns casos, mas 
não está diretamente relacionado com o polimorfismo paramétrico. Em C++, não há suporte para anotações. 
 
Gabarito: Letra A 
 
46. (FAURGS – UFCSPA - RS – 2018) Analise o trecho de código abaixo, escrito em C++. 
 
class classe_base { 
private: 
 int a; 
 float x; 
protected: 
 int b; 
 float y; 
public: 
 int c; 
 float z; 
}; 
 
class subclasse_1 : public classe_base {...}; 
 
class subclasse_2 : private classe_base {...}; 
 
class subclasse_3 : private classe_base {...}; 
Com base nesse código, é correto afirmar que 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
155
180
 
 
 
a) na subclasse_1 os atributos b e y são protegidos. 
b) na subclasse_1 os atributos c e z são privados. 
c) na subclasse_2 os atributos b e y são públicos. 
d) na subclasse_2 os atributos c e z são protegidos. 
e) as instâncias da subclasse_3 podem acessar o atributo c. 
 
Comentários: 
 
Na subclasse_1, a classe derivada herdou a classe base com a palavra-chave "public". Isso significa que os 
membros públicos e protegidos da classe base serão herdados como protegidos pela subclasse. Portanto, a 
subclasse_1 terá os atributos b e y protegidos. As demais afirmativas estão incorretas: Na subclasse_1, os 
atributos c e z são públicos. Na subclasse_2, os atributos da classe base serão privados. Na subclasse_3, os 
atributos da classe base serão privados, e as instâncias da subclasse_3 não podem acessar o atributo c 
diretamente. 
Gabarito: Letra A 
 
47. (COTEC – Câmara de Rio Pardo de Minas - MG – 2018) Analise o código a seguir, escrito na linguagem 
de programação C. 
 
#include <stdio.h> 
 
void sub(int *x, int y){ 
 *x = 3; 
 y = *x + 1; 
} 
 
int main() { 
 int a, b, z; 
 a = 1; 
 b = 2; 
 sub(&a,b); 
 z = a + b; 
 printf("%d",z); 
 return 0; 
} 
 
O valor de Z, a ser mostrado na saída padrão, é: 
 
a) 3. 
b) 4. 
c) 5. 
d) 7. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
156
180
 
 
 
No código, a função sub é chamada com o endereço da variável a e o valor da variável b como parâmetros. 
Dentro da função sub, o valor do inteiro apontado pelo ponteiro x é definido como 3, mas o valor de y 
passado como parâmetro não é afetado. Em seguida, no main, a variável z é definida como a soma de a (que 
agora tem valor 3) e b (que mantém seu valor original de 2), resultando em z igual a 5. Por fim, o valor de z 
é impresso na tela com o comando printf("%d", z);. 
 
Gabarito: Letra C 
 
48. (INSTITUTO AOCP – ITEP - RN – 2018) Em C++, como se denomina um conjunto de funções que 
compartilha um mesmo nome, porém contendo um código independente em cada uma? 
 
a) Redundância. 
b) Objeto. 
c) Encapsulamento. 
d) Polimorfismo. 
e) Herança. 
 
Comentários: 
 
A resposta correta é D - Polimorfismo. Em C++, um conjunto de funções que compartilha o mesmo nome, 
mas possui um código independente em cada uma, é conhecido como funções polimórficas. O polimorfismo 
é uma técnica que permite que objetos de diferentes classes sejam tratados como se fossem do mesmo tipo, 
e é um dos pilares da programação orientada a objetos. 
 
Gabarito: Letra D 
 
49. (INSTITUTO AOCP – ITEP - RN – 2018) Na linguagem C++, qual é a palavra-chave utilizada para a criação 
de novos tipos de dados? 
 
a) setw. 
b) while. 
c) struct. 
d) #include. 
e) #define. 
 
Comentários: 
 
A resposta correta é a alternativa "c) struct". A palavra-chave "struct" é utilizada na linguagem C++ para a 
criação de novos tipos de dados definidos pelo usuário. Com ela, é possível definir uma estrutura de dados 
contendo vários campos, cada um com seu próprio tipo. Essa estrutura pode ser usada para criar objetos do 
tipo definido pela estrutura, permitindo assim que o programador crie tipos de dados mais complexos e 
adaptados às suas necessidades.As outras alternativas apresentadas na questão são: 
 
a) "setw" é uma função da biblioteca padrão que permite definir a largura do campo de impressão em saídas 
formatadas para a tela ou arquivo. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
157
180
 
 
 
 
b) "while" é uma palavra-chave utilizada na linguagem C++ para implementar laços de repetição enquanto 
uma determinada condição é verdadeira. 
 
d) "#include" é uma diretiva do pré-processador que permite incluir o conteúdo de um arquivo de cabeçalho 
em um programa C++. 
 
e) "#define" é uma diretiva do pré-processador que permite definir uma constante ou um macro em um 
programa C++. 
Gabarito: Letra C 
 
50. (INSTITUTO AOCP – ITEP - RN – 2018) Qual das alternativas a seguir apresenta somente tipos de dados 
básicos da linguagem C? 
 
a) char, int e float. 
b) string, double e int. 
c) boolean, string e float. 
d) char, boolean e int. 
e) string, float e int. 
 
Comentários: 
 
A resposta correta é a alternativa a) char, int e float. Os tipos de dados básicos da linguagem C são: 
 
• char: tipo que representa caracteres. 
• int: tipo que representa números inteiros. 
• float: tipo que representa números de ponto flutuante de precisão simples. 
 
As outras alternativas apresentam pelo menos um tipo de dado que não é considerado básico na linguagem 
C: 
 
b) string: não é um tipo de dado básico na linguagem C, mas pode ser representado utilizando um array de 
caracteres. 
c) boolean e string: a linguagem C não possui um tipo de dado booleano nativo, e string também não é um 
tipo básico. 
d) boolean: como mencionado anteriormente, a linguagem C não possui um tipo de dado booleano nativo. 
e) string: novamente, string não é um tipo de dado básico na linguagem C. 
Portanto, apenas a alternativa a) apresenta somente tipos de dados básicos da linguagem C. 
 
Gabarito: Letra A 
 
51. (INSTITUTO AOCP – ITEP - RN – 2018) Em relação às principais caraterísticas da linguagem C, assinale a 
alternativa correta. 
 
a) Por ser uma linguagem de alto nível, não permite a manipulação de bits, bytes e endereços. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
158
180
 
 
 
b) Os códigos em C desenvolvidos para um determinado tipo de sistema operacional não são portáveis 
para outro sistema. Em outras palavras, a linguagem C não possui portabilidade. 
c) A linguagem C é estruturada em blocos, de modo que permite a criação de funções dentro de funções. 
d) A linguagem C permite a compartimentalização de código, escondendo do resto do programa as 
informações necessárias para realizar uma tarefa específica. 
e) É uma linguagem orientada a objeto. 
 
Comentários: 
 
a) ERRADO. A linguagem C permite a manipulação de bits, bytes e endereços, por isso é comumente utilizada 
em programação de sistemas embarcados e de baixo nível. 
b) ERRADO. Embora a portabilidade possa ser um problema em alguns casos, a linguagem C é conhecida por 
sua alta portabilidade, o que significa que o mesmo código pode ser compilado e executado em diferentes 
plataformas e sistemas operacionais. 
c) ERRADO. A linguagem C não permite a criação de funções dentro de outras funções, já que a função tem 
que ser declarada antes ou depois do escopo principal (main) do programa. 
d) CORRETO. Uma das principais características da linguagem C é a capacidade de dividir o código em funções 
e módulos, permitindo a criação de bibliotecas e a reutilização de código. Isso facilita a manutenção do 
código e torna o programa mais modular e organizado. 
e) ERRADO. A linguagem C não é uma linguagem orientada a objetos, embora possa ser usada para 
programação orientada a objetos com a utilização de bibliotecas e estruturas de dados personalizadas. 
 
Gabarito: Letra D 
 
52. (IBADE – IPM - JP – 2018) Considere o seguinte programa escrito na linguagem C 
 
#include <stdio.h> 
main () 
{char ex3[5]={'z','k','w','x','v'}; 
int cont1; 
cont1=2; 
printf ("%c %c",ex3[cont1+1], ex3[4]+cont1);} 
 
Ao executar esse programa, é apresentado como resposta: 
 
a) w w 
b) w x 
c) w v 
d) x x 
e) x v 
 
Comentários: 
 
O programa declara um array de caracteres "ex3" com tamanho 5 e preenche com as letras z, k, w, x, v. Em 
seguida, é declarada uma variável inteira "cont1" e é atribuído o valor 2. Na linha seguinte, é impresso o 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
159
180
 
 
 
conteúdo da posição "cont1+1" do array "ex3", que é o elemento de índice 3 (w). Na segunda parte do 
comando printf é impressa a soma do elemento de índice 4 do array "ex3" (v) com o valor de "cont1" (2), 
resultando na letra x. Portanto, a resposta correta é a letra B: "w x". 
Gabarito: Letra D 
 
53. (IBADE – Câmara de Cacoal - RO– 2018) Considere o seguinte programa escrito na linguagem C 
 
#include <stdio.h> 
 
int main() { 
 int g=0,i=0,l=0,k=0; 
 int m,n,o; 
 
 while (i<=10) { 
 m=g++; 
 n=+l; 
 o=++k; 
 i++; 
 } 
 printf (" m=%d n=%d o=%d ", m,n,o); 
 return 0; 
} 
 
Ao executar esse programa, os valores finais de ,e são respectivamente: 
 
a) 10 0 11 
b) 10 0 12 
c) 10 10 11 
d) 11 0 11 
e) 11 10 12 
 
Comentários: 
 
O programa apresentado define algumas variáveis inteiras e inicia cada uma delas com zero. Em seguida, um 
loop while é iniciado, e a cada iteração, as variáveis m, n e o recebem valores de expressões que contêm as 
variáveis g, l e k. m recebe o valor de g pós-incrementado, enquanto n recebe o valor de l sem alteração. Já 
o recebe o valor de k pré-incrementado. O loop while é executado enquanto i for menor ou igual a 10, e a 
cada iteração o valor de i é incrementado. No final do programa, é chamada a função printf para exibir os 
valores finais das variáveis m, n e o. Como g é pós-incrementado a cada iteração do loop, m receberá o valor 
de 10, já que a última atribuição a g é feita quando i é igual a 10. Como n recebe sempre o valor de l, que é 
zero em todas as iterações, n será igual a 0. Já o recebe o valor de k pré-incrementado a cada iteração, por 
isso será igual a 11 no final do loop. Portanto, a resposta correta é a alternativa A: 10 0 11. 
 
Gabarito: Letra A 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
160
180
 
 
 
54. (IBFC – Prefeitura de Divinópolis - MG – 2018) Referente à linguagem de programação C++, uma de suas 
características marcantes é a existência de: 
 
a) encapsulamento triplo 
b) herança múltipla 
c) polimorfismo duplo 
d) abstração complexa 
 
Comentários: 
 
Uma das principais características marcantes da linguagem de programação C++ é a herança múltipla, que 
permite a uma classe herdar características de mais de uma classe base. Isso pode tornar o código mais 
flexível e reutilizável, mas também pode tornar a hierarquia de classes mais complexa e difícil de entender. 
O encapsulamento é outra característica importante do C++, que permite que os dados sejam ocultados de 
outras partes do programa para evitar conflitos e garantir a segurança dos dados. O polimorfismo permite 
que objetos de diferentes classes sejam tratados de maneira semelhante, independentemente de suas 
diferenças de implementação. A abstração é uma característica maisampla que se aplica a muitas linguagens 
de programação, incluindo o C++, e envolve a capacidade de simplificar e generalizar o código para torná-lo 
mais fácil de entender e trabalhar. 
Gabarito: Letra B 
 
55. (COPESE – UFPI – 2018) Analise as assertivas a seguir sobre as linguagens de programação C, C++, Python 
e Java. 
 
I. A linguagem Python é uma linguagem interpretada e imperativa; 
 
II. Java, assim como C++, é um exemplo de linguagem que segue o paradigma de orientação a objetos; 
 
III. O identificador % é utilizado para identificar um comentário que utiliza somente uma linha em um 
programa escrito na linguagem C; 
 
IV. A linguagem de programação JAVA não fornece suporte à criação de tipos definidos pelo usuário. 
 
Assinale a opção referente às assertivas CORRETAS. 
 
a) Está correta somente a assertiva I. 
b) Estão corretas somente as assertivas I e III. 
c) Estão corretas somente as assertivas I e II. 
d) Estão corretas somente as assertivas III e IV. 
e) Estão corretas somente as assertivas II e IV. 
 
Comentários: 
 
A assertiva I está correta, pois Python é uma linguagem de script interpretada e imperativa. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
161
180
 
 
 
A assertiva II está correta, pois tanto Java quanto C++ são linguagens de programação orientadas a objetos. 
 
A assertiva III está incorreta, pois em C, o identificador para comentários que ocupam uma linha é //, 
enquanto % é utilizado em formatação de saída de dados com a função printf. 
 
A assertiva IV está incorreta, pois Java permite a criação de tipos definidos pelo usuário por meio de classes 
e interfaces. 
Gabarito: Letra C 
 
56. (FAPEC – UFMS – 2018) Considere o código a seguir escrito na linguagem C. 
 
#include <stdio.h> 
int main() 
{ 
 printf ("Valor total: %.1f\n", 9.1415169265); 
 return 0; 
} 
 
Assinale a alternativa que apresenta a saída correta. 
 
a) Valor total: 9.141517 
b) Valor total: 9.1 
c) Valor total: 9.14 
d) Valor total: 9.142 
e) Valor total: 9.141517e+00 
 
Comentários: 
 
A resposta correta é a letra B: Valor total: 9.1. A formatação %.1f indica que apenas um dígito após a vírgula 
deve ser exibido. No número 9.1415169265, o dígito seguinte ao 1 é o 5, que é maior ou igual a 5, portanto, 
ocorre o arredondamento para 9.2. No entanto, como foi especificado apenas um dígito após a vírgula, o 
resultado final é 9.1. 
Gabarito: Letra B 
 
57. (FAPEC – UFMS – 2018) Considere as afirmações sobre a linguagem C. 
 
I - É considerada uma linguagem fortemente tipada. 
 
II - É uma linguagem orientada a objetos. 
 
III - A função scanf é utilizada para ler dados da entrada padrão. 
 
Está(ão) correta(s): 
 
a) Apenas I. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
162
180
 
 
 
b) Apenas II. 
c) Apenas I e III. 
d) Apenas II e III. 
e) I, II e III. 
 
Comentários: 
 
A assertiva I está correta, pois a linguagem C é considerada uma linguagem fortemente tipada, o que significa 
que o tipo das variáveis deve ser definido antes de serem utilizadas e não podem ser implicitamente 
convertidas para outros tipos. A assertiva II está incorreta, pois a linguagem C não é orientada a objetos, 
embora permita a programação estruturada. A assertiva III está correta, pois a função scanf é utilizada para 
ler dados da entrada padrão, como teclado, e armazená-los nas variáveis correspondentes. 
 
Gabarito: Letra C 
 
58. (UFTM – UFTM – 2018) Aponte, dentre as alternativas, os resultados da resolução da seguinte expressão 
lógica escrita na linguagem C, para os valores de A, B e C, definidos nos cenários I, II e III: 
 
(A &&B ) && ((C || A || B) || ( !A && C)) 
 
I: A=true, B=true, C=false 
II: A=false, B=true, C=true 
III: A=false, B=true, C=false 
 
a) I: true, II: false, III: false. 
b) I: true, II: true, III: false. 
c) I: false, II: false, III: false. 
d) I: false, II: true, III: false. 
 
Comentários: 
 
Para o cenário I temos: 
 
(A && B) && ((C || A || B) || (!A && C)) 
(true && true) && ((false || true || true) || (!true && false)) 
true && true 
true 
 
Para o cenário II temos: 
 
(A && B) && ((C || A || B) || (!A && C)) 
(false && true) && ((true || false || true) || (!false && true)) 
false && true 
false 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
163
180
 
 
 
Para o cenário III temos: 
 
(A && B) && ((C || A || B) || (!A && C)) 
(false && true) && ((false || false || true) || (!false && false)) 
false && true 
false 
 
Logo, a alternativa correta é a A. 
Gabarito: Letra A 
 
59. (UFTM – UFTM – 2018) Considere o trecho de código em C abaixo: 
 
#include <stdio.h> 
 
void troca(int a, int b) { 
 int temp = a; 
 a = b; 
 b = temp; 
} 
 
int calcula(int a, int b, int *c) { 
 *c = a - b; 
 return a * (b + 1); 
} 
 
int main() { 
 int x, y, w, z; 
 x = 5; 
 y = 4; 
 troca(x, y); 
 z = calcula(x, y, &w); 
 printf("%d,%d", w, z); 
 return 0; 
} 
 
O que será exibido no console, quando a função main for executada? 
 
a) 1,25 
b) -1,24 
c) 1,24 
d) -1,25 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
164
180
 
 
 
No trecho de código fornecido, a função "troca" não está realizando a troca de fato, pois os parâmetros são 
passados por valor e não por referência. Portanto, as variáveis x e y na função main permanecem inalteradas. 
Em seguida, a função "calcula" é chamada com x=5 e y=4 e um ponteiro para a variável w é passado como 
terceiro argumento. Dentro da função "calcula", é calculado o valor de a-b e armazenado na posição de 
memória apontada por c (ou seja, na variável w na função main), e o valor a*(b+1) é retornado e armazenado 
em z na função main. Por fim, são impressos os valores de w e z separados por vírgula. Como a=5 e b=4, 
temos que c=a-b=1 e a*(b+1)=5*5=25. Portanto, os valores impressos serão "1,25". 
 
Gabarito: Letra A 
 
60. (UFES – UFES – 2018) Analise o trecho de código C++ abaixo. 
#include <stdio.h> 
 
class MinhaClasse { 
private: 
 int a; 
 
public: 
 MinhaClasse(int b) { 
 a = b; 
 ImprimeA(); 
 } 
 
 ~MinhaClasse() { 
 IncrementaA(); 
 ImprimeA(); 
 } 
 
 void IncrementaA() { 
 a++; 
 } 
 
 void ImprimeA() { 
 printf("[%d]", a); 
 } 
}; 
 
int main() { 
 MinhaClasse *mClasseD = new MinhaClasse(1); 
 MinhaClasse mClasseE(10); 
 return 0; 
} 
 
Considerando os conceitos de gerenciamento dinâmico de memória, o código C++ acima imprimirá na 
saída padrão: 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
165
180
 
 
 
a) [1][10][11][2] 
b) [1][10][2][11] 
c) [1][10][11] 
d) [1][10][2] 
e) [1][10] 
 
Comentários: 
 
A resposta correta é a alternativa C: "[1][10][11]". Isso porque o código cria duas instâncias da classe 
MinhaClasse: uma através da alocação dinâmica de memória com o operador new e outra na pilha de 
execução da função main(). A primeira instância criada, mClasseD, é criada com o construtor que recebeo 
parâmetro int b com valor 1. Ao imprimir o valor de a, é exibido "[1]". Em seguida, é chamado o destrutor da 
classe MinhaClasse, que incrementa o valor de a para 2 e imprime "[2]". A segunda instância criada, 
mClasseE, é criada na pilha de execução da função main() com o construtor que recebe o parâmetro int b 
com valor 10. Ao imprimir o valor de a, é exibido "[10]". Quando a função main() termina, o destrutor de 
mClasseE é chamado automaticamente, incrementando o valor de a para 11 e imprimindo "[11]". Portanto, 
a saída padrão será "[1][10][11]". 
Gabarito: Letra C 
 
61. (UFES – UFES – 2018) Analise o trecho de código C++ abaixo. 
 
using namespace std; 
int main() { 
 int arr[] = {10, 7, 2, 15, 4}; 
 vector<int> v(arr, arr + 5); 
 vector<int>::iterator it; 
 sort(v.rbegin(), v.rend()); 
 for (it = v.begin(); it != v.end(); it++) 
 printf("[%d]", *it); 
 return 0; 
} 
 
Considerando os conceitos de iteradores e algoritmos presentes na Standard Template Library (STL), o 
código C++ acima imprimirá na saída padrão: 
 
a) [4][15][2][7][10] 
b) [2][4][7][10][15] 
c) [10][7][2][15][4] 
d) [15][10][7][4][2] 
e) [7][9][13][15][20] 
 
Comentários: 
 
O trecho de código C++ apresenta a criação de um vetor "arr" com 5 elementos e em seguida é criado um 
objeto da classe vector "v" que recebe como argumentos os elementos do vetor "arr" utilizando a função 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
166
180
 
 
 
begin e end. Depois é declarado um iterador "it" do tipo vector<int>::iterator para percorrer o vetor "v". Em 
seguida, é chamada a função sort para ordenar o vetor em ordem decrescente, utilizando os iteradores 
rbegin() e rend(). Por fim, é feita a impressão na saída padrão utilizando o iterador "it" e um laço for. Assim, 
a resposta correta é a letra D, que corresponde à impressão dos elementos do vetor ordenados em ordem 
decrescente: [15][10][7][4][2]. 
Gabarito: Letra D 
 
62. (UFES – UFES – 2018) Um recurso relevante da linguagem C++ é o que declara membros de classe como 
static. O objetivo de se declarar um membro de classe como static em C++ é permitir que 
 
a) apenas uma cópia do membro seja compartilhada por todos os objetos da classe. 
b) cada objeto de uma classe tenha sua própria cópia do membro. 
c) o membro seja estático e seu valor não se altere durante a execução do código. 
d) o membro tenha um nome fixo durante a execução do código. 
e) se armazenem valores únicos. 
 
Comentários: 
 
A alternativa A está correta. Ao se declarar um membro de classe como static em C++, apenas uma cópia 
desse membro é criada e compartilhada por todos os objetos da classe, ou seja, não há uma cópia do 
membro para cada objeto criado. Dessa forma, o valor do membro é compartilhado e atualizado para todos 
os objetos que o acessam. Esse recurso pode ser útil em diversas situações, como para armazenar 
informações comuns a todos os objetos da classe ou para contar o número de objetos criados daquela classe. 
 
Gabarito: Letra A 
 
63. (UFES – UFES – 2018) Após reconhecer que muitas estruturas de dados e algoritmos são comumente 
utilizadas por programadores em C++, o comitê-padrão adicionou a Standard Template Library (STL) à 
C++ Standard Library. Os contêineres são estruturas de dados baseadas em templates populares. Sobre 
os contêineres da STL em C++, é INCORRETO afirmar: 
 
a) O contêiner set permite pesquisa rápida e não permite duplicatas. 
b) O contêiner priority_queue permite inserções ou exclusões rápidas em sua parte dianteira ou traseira 
e acesso direto a qualquer elemento desse tipo de contêiner. 
c) O contêiner multiset permite pesquisa rápida e duplicatas. 
d) No contêiner stack, o último elemento a entrar é o primeiro a sair. 
e) O contêiner vector permite inserções e exclusões rápidas na parte traseira e acesso direto a qualquer 
elemento desse tipo de contêiner. 
 
Comentários: 
 
A afirmativa incorreta é a letra B. O contêiner priority_queue não permite acesso direto a qualquer elemento, 
apenas a inserção ou exclusão rápidas em sua parte dianteira ou traseira. Acesso direto aos elementos é 
permitido em contêineres como vector e deque. As demais afirmativas estão corretas: o set permite pesquisa 
rápida e não permite duplicatas; o multiset permite pesquisa rápida e permite duplicatas; no stack, o último 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
167
180
 
 
 
elemento a entrar é o primeiro a sair; e o vector permite inserções e exclusões rápidas na parte traseira e 
acesso direto a qualquer elemento. 
Gabarito: Letra B 
 
64. (UFES – UFES – 2018) Observe o trecho de código em C abaixo, que implementa uma função f1 que tem 
uma string como parâmetro. 
 
void fl(char* str) { 
 while (*str) { 
 if (*str == ' ') { 
 *str = '-'; 
 } 
 str++; 
 } 
} 
 
Assumindo que a chamada da função foi feita passando uma string válida qualquer como argumento, é 
CORRETO afirmar sobre o código acima: 
 
a) o código da função entrará em laço infinito ao ser executado, pois, considerando-se uma string na 
linguagem C, a condição de parada está errada. 
b) o objetivo da função é substituir os caracteres do tipo espaço (i.e., ‘ ’) da string recebida por meio do 
parâmetro str por caracteres do tipo traço (i.e., ‘-’). 
c) o código da função acessará uma posição inválida de memória ao ser executado, pois, considerando-
se uma string na linguagem C, o incremento está errado. 
d) a função não fará nenhuma alteração na string recebida pelo parâmetro str, pois a execução nunca 
entrará no comando de laço. 
e) o objetivo da função é verificar se existem caracteres do tipo espaço e responder “verdadeiro”, caso 
haja, ou “falso”, em caso contrário. 
 
Comentários: 
 
A função implementada acima tem como objetivo substituir os caracteres do tipo espaço por traço na string 
recebida por meio do parâmetro str. Portanto, a alternativa correta é a letra b). 
a) o código da função entrará em laço infinito ao ser executado, pois, considerando-se uma string na 
linguagem C, a condição de parada está errada. 
b) o objetivo da função é substituir os caracteres do tipo espaço (i.e., ‘ ’) da string recebida por meio do 
parâmetro str por caracteres do tipo traço (i.e., ‘-’). 
c) o código da função acessará uma posição inválida de memória ao ser executado, pois, considerando-se 
uma string na linguagem C, o incremento está errado. 
d) a função não fará nenhuma alteração na string recebida pelo parâmetro str, pois a execução nunca entrará 
no comando de laço. 
e) o objetivo da função é verificar se existem caracteres do tipo espaço e responder “verdadeiro”, caso haja, 
ou “falso”, em caso contrário. 
Gabarito: Letra B 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
168
180
 
 
 
 
65. (UFES – UFES – 2018) O trecho de código em C abaixo implementa uma função f1 para imprimir, na saída 
padrão, a sigla de um estado, composta por dois caracteres e recebida por meio do parâmetro sigla, e, 
em seguida, imprimir um caractere de quebra de linha. 
 
void f1(char* sigla) { 
 char lSigla[2]; 
 lSigla[0] = sigla[0]; 
 lSigla[1] = sigla[1]; 
 printf("%s\n", lSigla); 
} 
 
Analise as afirmativas a seguir, acerca do trecho de código acima: 
I. Os dois caracteres da sigla do estado passada como argumento serão impressos e serão seguidos 
imediatamente por um caractere de quebrade linha. 
 
II. A troca da linha printf("%c%c\n", lSigla[0],lSigla[1]); pela linha original printf("%s\n", lSigla); produziria 
o resultado desejado. 
 
III. Os dois caracteres da sigla do estado passada como argumento serão impressos primeiramente, mas 
não se pode prever o que será impresso entre a segunda letra da sigla e o caractere de quebra de linha. 
 
IV. Não se pode prever nenhum dos caracteres que serão impressos, mesmo que se conheça a sigla do 
estado passada como argumento. 
 
É CORRETO o que se afirma em 
 
a) II e III, apenas. 
b) II, apenas. 
c) IV, apenas. 
d) III, apenas. 
e) I e IV, apenas. 
 
Comentários: 
 
A afirmativa I está correta, já que a função f1 imprime os dois caracteres da sigla seguidos por um caractere 
de quebra de linha. A afirmativa II está incorreta, já que a troca da linha de impressão para printf("%c%c\n", 
lSigla[0],lSigla[1]) irá imprimir os caracteres da sigla separados por um espaço, em vez de serem 
concatenados em uma string. A afirmativa III está correta, já que não há nenhum caractere sendo 
explicitamente colocado entre as duas letras da sigla na impressão, mas a função printf pode inserir alguns 
caracteres especiais, dependendo do sistema operacional e da configuração. A afirmativa IV está incorreta, 
já que a sigla é claramente definida no código e os caracteres que serão impressos podem ser previstos. 
Portanto, a resposta correta é a letra A: II e III, apenas. 
Gabarito: Letra A 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
169
180
 
 
 
66. (FADESP – IF-PA – 2018) Analise as afirmações sobre as linguagens de programação. 
 
I. O mecanismo de herança em Java ocorre em tempo de compilação, ou seja, todo reaproveitamento de 
código realizado por herança é imutável em tempo de execução. 
II. A linguagem C++ possui herança múltipla, Java possui somente herança simples para classes concretas 
e abstratas, mas possui herança múltipla para a “interface”, já Javascript não possui herança como 
funcionalidade nativa. 
III. C++ é uma linguagem compilada, Java é compilada para uma linguagem de máquina intermediária 
chamada de bytecodes, sendo esta interpretada e Javascript é interpretada. 
 
É correto afirmar que 
 
a) somente a afirmativa II é verdadeira. 
b) somente as afirmativas I e III são verdadeiras. 
c) somente as afirmativas I e II são verdadeiras. 
d) somente a afirmativa III é verdadeira. 
e) as afirmativas I, II e III são verdadeiras. 
 
Comentários: 
 
A questão apresenta algumas afirmações sobre linguagens de programação e pede que o candidato analise 
cada uma delas e determine a correta. A primeira afirmação é correta e se refere ao mecanismo de herança 
em Java, que é determinado em tempo de compilação e não pode ser alterado em tempo de execução. Já a 
segunda afirmação é incorreta ao afirmar que JavaScript não possui herança como funcionalidade nativa. De 
fato, a linguagem possui suporte à herança, embora de uma maneira diferente da maioria das outras 
linguagens. A terceira afirmação é correta e se refere à maneira como as linguagens C++, Java e JavaScript 
são compiladas ou interpretadas. Assim, a alternativa correta é a letra B, que afirma que somente as 
afirmações I e III são verdadeiras. 
Gabarito: Letra B 
 
67. (NUCEPE – SEDUC-PI – 2018) A estrutura de repetição for possui três campos que devem ser preenchidos. 
Conforme o exemplo a seguir, esses três campos são chamados respectivamente de: 
 
for (contador = 1; contador <= 10; contador++) 
{ 
 printf("%d", contador); 
} 
getch(); 
return(0); 
} 
 
a) inicialização, condição e iteração. 
b) incremento, condição e inicialização. 
c) condição, inicialização e incremento. 
d) inicialização, condição e iteração. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
170
180
 
 
 
e) inicialização, condição e iteração. 
 
Comentários: 
 
A alternativa correta é a letra E: inicialização, condição e iteração. Os três campos da estrutura de repetição 
for são, nessa ordem: a inicialização da variável de controle, a condição para a execução do loop e a iteração 
da variável de controle. No exemplo dado, a variável "contador" é inicializada com o valor 1, a condição de 
execução é que o contador seja menor ou igual a 10 e a iteração é feita através do incremento do contador 
em uma unidade a cada iteração do loop. 
Gabarito: Letra E 
 
68. (NUCEPE – SEDUC-PI – 2018) Analise o trecho do código a seguir e marque a única alternativa CORRETA 
em relação ao resultado da execução do programa. 
 
#include <iostream> 
 
void impr3() { 
 std::cout << "3" << std::endl; 
} 
 
void impr2() {} 
 
void impr1() { 
 std::cout << "1" << std::endl; 
} 
 
int main() { 
 impr3(); 
 std::cout << "2" << std::endl; 
 impr1(); 
 impr2(); 
 return 0; 
} 
 
a) 2 3 1 
b) 1 3 2 
c) 1 2 3 
d) 3 2 1 
e) 2 1 3 
 
Comentários: 
 
A resposta correta é a alternativa B, que corresponde à sequência de saída "1 3 2". Isso porque a função 
impr3() é chamada logo no início do programa, imprimindo o número 3. Em seguida, o número 2 é impresso 
com o comando "std::cout << "2" << std::endl;", e depois a função impr1() é chamada, imprimindo o número 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
171
180
 
 
 
1. A função impr2() não tem nenhum comando dentro dela e não produz saída. Portanto, a sequência correta 
de saída é "1 3 2". 
Gabarito: Letra B 
 
69. (NUCEPE – SEDUC-PI – 2018) De acordo com o código a seguir, qual comando estaria no lugar de 
***************? 
 
#include <iostream> 
 
int main(int argc, char *argv[]) { 
 int num1, num2; 
 std::cout << "Digite um numero: "; 
 *************** 
 std::cout << "Digite outro numero: "; 
 std::cin >> num1; 
 std::cout << "Os números digitados foram " << num1 << " e " << num2 << std::endl; 
 return 0; 
} 
 
a) scanf ("%d", &num3). 
b) scanf ("%d", &num1). 
c) scanf ("%d", &num2). 
d) scanf ("%f", &num2). 
e) scanf ("%f", &num1). 
 
Comentários: 
 
O código é um programa simples em C++ que solicita que o usuário digite dois números e os exibe na tela. O 
programa começa declarando duas variáveis inteiras, num1 e num2, e em seguida utiliza a biblioteca 
iostream para imprimir a mensagem "Digite um número:" na tela. Em seguida, o programa utiliza o operador 
de extração (>>) para obter um valor digitado pelo usuário e armazená-lo na variável num2. O programa 
então imprime outra mensagem "Digite outro número:", utilizando a mesma sintaxe. Depois disso, o 
operador de extração (>>) é utilizado novamente para obter um segundo valor digitado pelo usuário e 
armazená-lo na variável num1. Finalmente, o programa imprime uma mensagem que combina os valores de 
num1 e num2 e encerra sua execução. O comando correto para ler um valor inteiro do usuário e armazená-
lo na variável num2 em C++ é "std::cin >> num2;". O comando scanf é utilizado em C para a mesma finalidade. 
 
Gabarito: Letra C 
 
70. (NUCEPE – SEDUC-PI – 2018) O programa em linguagem C abaixo imprime os números pares que estão 
no intervalo de 0 a 50, em ordem crescente. Qual o incremento correto? 
 
int i 
 for (i=0; i<=50; ****X{ 
 printf("%d ", i); 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOSSANTOS
172
180
 
 
 
} 
 
a) i++ 
b) cont = cont + 1 
c) cont = i++ 
d) i = i + 1 
e) i = i + 2 
 
Comentários: 
 
O incremento correto seria a alternativa E, isto é, "i = i + 2". Isso porque o objetivo é imprimir somente 
números pares, e como todo número par é divisível por 2, é necessário incrementar o valor de i com um 
passo de 2 em 2 para que sejam considerados somente os números pares no intervalo de 0 a 50. 
 
Gabarito: Letra E 
 
71. (UFMT – UFSBA – 2017) A sobrecarga de operadores é uma técnica muito utilizada em C++. Assinale a 
alternativa que NÃO apresenta um operador que possa ser sobrecarregado em C++. 
 
a) "new" 
b) "new[]" 
c) "+" 
d) "?:". 
 
Comentários: 
 
A sobrecarga de operadores é uma técnica importante em C++, que permite aos desenvolvedores definir 
comportamentos personalizados para os operadores existentes na linguagem. Os operadores mencionados 
nas opções B e C - "new[]" e "+" - também podem ser sobrecarregados em C++. Vejamos cada alternativa. A) 
"new": "new" é um operador em C++ usado para alocar memória dinamicamente durante a execução de um 
programa. No entanto, esse operador não pode ser sobrecarregado, pois ele é um operador de membro e a 
linguagem C++ não permite a sobrecarga de operadores de membro. B) "new[]": "new[]" é um operador em 
C++ usado para alocar dinamicamente uma matriz de elementos em tempo de execução. Esse operador pode 
ser sobrecarregado para personalizar o comportamento da alocação dinâmica de matrizes. C) "+": "+" é um 
operador em C++ usado para realizar a operação de adição em dois valores. Esse operador pode ser 
sobrecarregado para personalizar o comportamento da adição de valores. D) "?:": "?:", também conhecido 
como operador ternário, é um operador condicional em C++ que retorna um dos dois valores, dependendo 
de uma condição. Esse operador pode ser sobrecarregado para personalizar o comportamento do operador 
ternário condicional. 
 
Gabarito: Letra D 
 
72. (UFMT – UFSBA – 2017) Assinale a alternativa que representa, na linguagem de programação C, a 
estrutura de repetição for que, por meio da variável de controle i, percorre o intervalo do índice 0 até o 
índice 32 inclusive, na ordem não decrescente. 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
173
180
 
 
 
a) for(i = 32; i > 0; i--) 
b) for(i = 32; i > -1; i--) 
c) for(i = 0; i < 33; i++) 
d) for(i = 0; i < 32; i++) 
 
Comentários: 
 
A alternativa que representa, na linguagem de programação C, a estrutura de repetição for que percorre o 
intervalo do índice 0 até o índice 32 inclusive, na ordem não decrescente, é a letra C: for(i = 0; i < 33; i++). 
Nesse loop for, a variável i é inicializada com 0, e a condição de parada é i < 33, que garante que o loop 
execute até que i chegue ao valor 33. O operador de incremento i++ garante que a variável i seja 
incrementada em cada iteração do loop. Assim, o loop executa 33 iterações, percorrendo o intervalo de 0 
até 32 inclusive, em ordem não decrescente. 
Gabarito: Letra C 
 
73. (UFRN – UFRN – 2017) Considere o seguinte código em C++ : 
 
int funcl(int paramA, int paramB) { 
 if (paramA > paramB) { 
 return funcl(paramA - paramB, paramB); 
 } else { 
 return paramA; 
 } 
} 
 
Nesse código, o algoritmo func1 implementa uma função matemática de 
 
a) divisão inteira 
b) resto da divisão inteira 
c) fatorial 
d) potenciação 
 
Comentários: 
 
O código em C++ implementa uma função que retorna o resto da divisão inteira de paramA por paramB. A 
função funcl utiliza recursividade para realizar a operação, subtraindo paramB de paramA enquanto paramA 
for maior que paramB. Quando paramA é menor ou igual a paramB, a função simplesmente retorna paramA, 
que será o resto da divisão inteira. Portanto, a alternativa correta é a letra B, que se refere ao resto da divisão 
inteira. 
 
Gabarito: Letra B 
 
74. (IF-CE – IF-CE – 2017) Considere as afirmações sobre os paradigmas de linguagens de programação. 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
174
180
 
 
 
I. Python, Ruby e Java são linguagens de programação interpretada multiparadigma, de tipagem dinâmica 
e forte. 
 
II. As linguagens de programação Object-Pascal, C++ e Java, embora deem suporte à Orientação a Objetos 
(OO), não são completamente orientadas a objetos. 
 
III. As linguagens de programação Smalltalk e Ruby são consideradas puramente orientadas a objetos, 
isto é, tudo é considerado um objeto, até mesmo os tipos básicos da linguagem. 
 
Está(ão) correta(s): 
 
a) II, apenas. 
b) I, II e III. 
c) III, apenas. 
d) I e II, apenas. 
e) II e III, apenas. 
 
Comentários: 
 
A resposta correta é a alternativa E. A afirmação I é verdadeira. Python, Ruby e Java são linguagens de 
programação interpretada multiparadigma, de tipagem dinâmica e forte. A afirmação II é falsa. Tanto C++ 
quanto Object-Pascal e Java são linguagens que dão suporte completo à Orientação a Objetos (OO). A 
afirmação III é verdadeira. Smalltalk e Ruby são linguagens consideradas puramente orientadas a objetos, 
pois tudo é considerado um objeto, inclusive os tipos básicos da linguagem. Portanto, as afirmações II e III 
estão corretas, enquanto a afirmação I está incorreta. A alternativa que corresponde a isso é a letra E. 
 
Gabarito: Letra E 
 
75. (IF-CE – IF-CE – 2017) Sabendo-se que programas de computador podem ser compilados ou 
interpretados, é verdadeiro dizer-se que programas 
 
a) desenvolvidos com Java igualmente aos desenvolvidos com C# são compilados. Ambos se utilizam de 
uma linguagem intermediária, para independer do sistema operacional. 
b) em PHP são interpretados tanto quanto programas em Java para web. 
c) em JavaScript funcionam Client-Side, ou seja, rodam no lado cliente, por isso precisam ser previamente 
compilados. 
d) desenvolvidos para internet precisam de um servidor de aplicação como IIS ou Apache. Devido a isso, 
são linguagens interpretadas pelo servidor. 
e) feitos com linguagem que precise de uma máquina virtual ou semelhante, como o Java, são executados 
e interpretados por ela em tempo de execução (Just-in-time), por isso não precisam ser compilados. 
 
Comentários: 
 
Pessoal, nosso gabarito é a letra A. Programas desenvolvidos em Java e C# são compilados e utilizam uma 
linguagem intermediária para serem executados de forma independente do sistema operacional. Essa 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
175
180
 
 
 
linguagem intermediária é conhecida como bytecode no caso do Java e IL (Intermediate Language) no caso 
do C#. PHP é uma linguagem interpretada, enquanto Java pode ser compilado ou interpretado, dependendo 
da implementação utilizada (por exemplo, a JVM pode compilar o bytecode para código nativo ou interpretá-
lo). JavaScript é uma linguagem interpretada que é executada no navegador do cliente (Client-Side) e não 
precisa ser previamente compilada. Programas desenvolvidos para internet não necessariamente precisam 
de um servidor de aplicação como IIS ou Apache, mas é comum que sejam executados em um ambiente de 
servidor e interpretados pelo servidor antes de serem enviados para o cliente. Linguagens que precisam de 
uma máquina virtual, como Java, geralmente são compiladas para bytecode e depois interpretadas pela 
máquina virtual em tempo de execução (Just-in-time), mas isso não significa que elas não precisam ser 
compiladas. 
 
Gabarito:Letra A 
 
76. (IFB – IFB – 2017) Analise as seguintes afirmativas. I) Ocultar dados dentro das classes e torná-los 
disponíveis apenas por meio de métodos é uma técnica muito usada em programas orientados a objetos, 
chamada de sobreescrita de classes. II) Uma subclasse pode implementar novamente métodos que foram 
herdados de uma superclasse. Chamamos isso de sobrecarga de atributos. III) Em Java não existe herança 
múltipla como em C++. Essa limitação pode ser parcialmente simulada pelo uso de encaminhamento de 
métodos a variáveis de instância. Assinale a alternativa CORRETA com relação às afirmativas acima. 
 
a) Apenas a afirmativa I está correta. 
b) Apenas a afirmativa II está correta. 
c) Apenas a afirmativa III está correta. 
d) Apenas as afirmativas I e III estão corretas. 
e) Apenas as afirmativas I e II estão corretas. 
 
Comentários: 
 
A afirmativa I está incorreta, pois a técnica mencionada é chamada de encapsulamento, não de sobreescrita 
de classes. A afirmativa II está incorreta, pois a definição correta de sobrecarga é quando uma classe tem 
vários métodos com o mesmo nome, mas com parâmetros diferentes. A afirmativa III está correta, pois em 
Java não é possível herdar de múltiplas classes, mas é possível implementar múltiplas interfaces e usar o 
encaminhamento de métodos para simular herança múltipla. 
 
Gabarito: Letra C 
 
77. (UFES – UFES – 2016) O código C abaixo se propõe a informar a média da idade de algumas pessoas com 
uma precisão de duas casas decimais, dados o número de pessoas (pessoas, com 0<pessoas<10) e suas 
respectivas idades. 
 
#include <stdio.h> 
 
int main() { 
 int pessoas, i, soma, idade; 
 double media; 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
176
180
 
 
 
 
 scanf("%d", &pessoas); 
 soma = 0; 
 
 for(i = 0; i < pessoas; i++) { 
 scanf("%d", &idade); 
 soma = soma + idade; 
 } 
 
 media = soma/pessoas; 
 printf("%.2f", media); 
 
 return 0; 
} 
 
A respeito do código acima, é CORRETO afirmar: 
a) O código faz corretamente o que é proposto. 
b) O código interrompe sua execução com um segmentation fault. 
c) O código pode ser corrigido para fazer o que se propõe, caso seja feita uma conversão de tipos no local 
apropriado. 
d) O código está errado, pois o formato do printf não é apropriado para impressão com precisão de duas 
casas decimais. 
e) O código está errado, pois a variável idade deveria ser dividida pela variável pessoas dentro do for, ou 
seja, soma = soma + idade/pessoas;. 
 
Comentários: 
 
O código se propõe a calcular a média da idade de um número específico de pessoas e exibir o resultado com 
uma precisão de duas casas decimais. O código faz a leitura do número de pessoas e em seguida lê as idades 
de cada pessoa, somando todas elas em uma variável "soma". Em seguida, o código calcula a média dividindo 
a soma pelo número de pessoas e armazenando o resultado na variável "media". Por fim, o código imprime 
o valor de "media" com precisão de duas casas decimais usando o formato de saída "%.2f". A opção correta 
é a letra C, pois embora o código esteja funcionando corretamente para o que se propõe, é possível que 
ocorra um erro caso o valor de "pessoas" seja maior ou igual a 10, já que o código não está preparado para 
lidar com esse caso. Além disso, o código poderia ser otimizado para utilizar uma variável do tipo "float" em 
vez de "double", já que a precisão necessária é de apenas duas casas decimais. 
 
Gabarito: Letra C 
 
78. (CESPE – TJ-SE– 2014) Para que a máquina entenda os comandos de um programa desenvolvido na 
linguagem C, o programa deve ser compilado e traduzido para a linguagem da máquina. 
 
Comentários: 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
177
180
 
 
 
Sim, essa afirmação está correta. O código escrito na linguagem C é interpretado pelo compilador da 
linguagem, que é responsável por traduzir o código para a linguagem de máquina que o computador é capaz 
de entender e executar. Sem o processo de compilação, o programa escrito em C não poderia ser executado 
diretamente pela máquina. 
 
Gabarito: Correto 
 
79. (CESPE – TJ-SE– 2014) O comando em linguagem C apresentado abaixo é um tipo de laço que pode ser 
finalizado com o comando break; portanto, esse comando não tem garantia de laço infinito. 
 
for (;;) printf ("Exemplo de laço infinito.\n") ; 
 
Comentários: 
 
O laço for apresentado não tem condição de término, portanto é um laço infinito. No entanto, é possível 
finalizá-lo com o uso do comando break em alguma condição dentro do próprio laço. 
 
Gabarito: Correto 
 
80. (CESPE – ANTT – 2014) O paradigma de orientação a objetos é amplamente utilizado em várias 
linguagens: Java é compilada em bytecode e executada em uma máquina virtual (JVM); C++ apresenta 
bom desempenho ao unir características de alto e de baixo níveis; Python/Ruby/PHP podem ser utilizadas 
para desenvolvimento web, mas sem aplicações para dispositivos móveis 
 
Comentários: 
 
A afirmação apresentada está incorreta. Embora Java seja compilada em bytecode e executada em uma 
máquina virtual (JVM), isso não significa que as outras linguagens mencionadas não possam ser usadas para 
desenvolvimento de aplicativos móveis. Na verdade, tanto Python quanto Ruby têm uma grande variedade 
de frameworks e bibliotecas disponíveis para desenvolvimento de aplicativos móveis, como Kivy, PyMob e 
Rubymotion. Além disso, o PHP também pode ser usado para o desenvolvimento de aplicativos móveis, 
embora em menor escala. 
Gabarito: Errado 
 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
178
180
 
 
 
GABARITO 
1. Letra B 
2. Correto 
3. Errado 
4. Errado 
5. Correto 
6. Letra D 
7. Letra B 
8. Letra C 
9. Letra C 
10. Letra C 
11. Letra A 
12. Letra C 
13. Letra B 
14. Letra A 
15. Letra A 
16. Letra B 
17. Letra B 
18. Letra D 
19. Letra C 
20. Letra A 
21. Letra D 
22. Letra B 
23. Letra A 
24. Letra A 
25. Letra B 
26. Letra D 
27. Letra B 
28. Letra A 
29. Letra C 
30. Letra D 
31. Letra A 
32. Letra C 
33. Letra B 
34. Letra C 
35. Letra B 
36. Letra D 
37. Letra D 
38. Letra D 
39. Letra C 
40. Letra D 
41. Letra A 
42. Letra E 
43. Letra B 
44. Letra C 
45. Letra A 
46. Letra A 
47. Letra C 
48. Letra D 
49. Letra C 
50. Letra A 
51. Letra D 
52. Letra D 
53. Letra A 
54. Letra B 
55. Letra C 
56. Letra B 
57. Letra C 
58. Letra A 
59. Letra A 
60. Letra C 
61. Letra D 
62. Letra A 
63. Letra B 
64. Letra B 
65. Letra A 
66. Letra B 
67. Letra E 
68. Letra B 
69. Letra C 
70. Letra E 
71. Letra D 
72. Letra C 
73. Letra B 
74. Letra E 
75. Letra A 
76. Letra C 
77. Letra C 
78. Correto 
79. Correto 
80. Errado 
 
Paolla Ramos
Aula 03 - Somente em PDF
POLITEC-PE (Perito Criminal - Área 5 - Ciências da Computação ou Sistemas de Informação) Desenvolvimento de Software - 2024 (Pós-Edital)
www.estrategiaconcursos.com.br
04397573395 - JOSIAS STONE PINHEIRO DOS SANTOS
179
180