Questões de Concurso sobre C e C++

 
 
Disciplina
Assunto 1
Banca
Instituição
Cargo
Ano
Carreira
Área de formação
Escolaridade
Dificuldade
 
Comentários:
Professores
Alunos
Meus Comentários
Vídeo
 
Minhas questões:
Resolvidas
Não resolvidas
Certas
Erradas
 
Tipo de questão:
Certo e errado
Múltipla escolha
Incluir questões:
Anuladas
Desatualizadas
 
Questões:
Todas as questões
 
Filtro simplificado
 
Questões
Todas as questões
 
415 questões encontradas
Questões por página
20
Mais recentes
 

Considere a expressão a = (x > y)? ((x > z)? x : z): ((y> z)? y : z) na linguagem de programação C++.


Para obter o valor 4 para a variável a, a combinação das variáveis inteiras x, y e z é


A

x = 6, y = 5, z = 3.


B

x = 5, y = 4, z = 5.


C

x = 3, y = 4, z = 2.


D

x = 6, y = 3, z = 5.


E

x = 6, y = 4, z = 5.

Considerando os construtores da linguagem de programação C++, é CORRETO afirmar:


A

A ordem de chamada dos construtores é idêntica à ordem de chamada dos destrutores, quando se trata de classes derivadas.


B

Os construtores de uma classe básica são herdados por classes derivadas.


C

Os construtores de uma classe derivada são herdados por classes básicas.


D

Os construtores de uma classe derivada não podem chamar construtores da classe básica.


E

Ao instanciar um objeto de uma classe derivada, inicia-se uma cadeia de chamadas de construtor em que o construtor da classe derivada, antes de realizar suas tarefas, invoca o construtor de sua classe básica.

Analise o código C++ abaixo.


#include <iostream>

#include <stack>

#include <queue>


int main(){

_______ std::queue<int> myqueue;

_______ std::stack<int> mystack;


_______ mystack.push(1);

_______ mystack.push(2);

_______ mystack.push(3);

_______ mystack.push(4);

_______ myqueue.push(5);

_______ myqueue.push(6);

_______ myqueue.push(7);

_______ myqueue.push(8);

_______ myqueue.pop();

_______ mystack.pop();


_______ std::cout << myqueue.front() +

mystack.top() << std::endl;

_______ return 0;

}


Considerando os conceitos de pilha e fila, o número a ser impresso após a execução do código C++ acima é:


A

10


B

9


C

8


D

7


E

2

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;

}


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;.

Na linguagem de programação C, cadeias de caracteres (ou Strings) são representadas por vetores do tipo char. O código abaixo chama uma função denominada apresentarString, que imprime o conteúdo da String armazenada em vet.


int main()

{

char vet[100] = "Eu sou uma string!";

apresentarString(vet);

return 0;

}


Das opções de implementação da função apresentarString abaixo, a que NÃO é capaz de imprimir a String corretamente (isto é, NÃO é capaz de imprimir: Eu sou uma string!) é:


A

void apresentarString(char * str){

_ if( *str == '\0' ){

__return;

_}

_printf("%c", *str);

_apresentarString(str++);

}


B

void apresentarString(char * str){

_int i = 0;

_for ( i = 0; str[i] != '\0'; i++ ){

__printf("%c", str[i]);

_}

}


C

_void apresentarString(char * str){

_int i = 0;

_while( str[i] != '\0' ){

__printf("%c", str[i]);

__i++;

__}

}


D

void apresentarString(char * str){

_int i = 0;

_while( *str != '\0' ){

__printf("%c", *str);

__str++;

_}

}


E

void apresentarString(char * str){

_if( *str == '\0' ){

__return;

_}

_printf("%c", *str);

_apresentarString(++str);

}

Na linguagem C++, é possível substituir as funções scanf("%d", &x) e printf("%d", y) da linguagem C, respectivamente, por


A

std::cout >> x e std::cin << y


B

std::cin >> x e std::cout << y


C

std::cin << x e std::cout >> y


D

std::cout << x e std::cin >> y

Dadas as afirmativas acerca das linguagens de programação Java, C++ e Python,


I. Das três linguagens consideradas, Java é a única que não permite sobrecarga de operadores.

II. O nível de dinamismo permitido pela linguagem Python, em termos de polimorfismo, é inferior às linguagens C++ e Java, uma vez que não possui construção equivalente aos Templates (de C++) e Generics (de Java).

III. Na linguagem C++, o padrão é o uso do acoplamento estático; e para optar pelo acoplamento dinâmico, é necessário utilizar a palavra reservada virtual.

IV. Na linguagem Java, o operador final somente pode ser utilizado para qualificar atributos, não podendo ser utilizado para qualificar métodos.


verifica-se que está(ão) correta(s)


A

II, apenas.


B

I e III, apenas.


C

II e IV, apenas.


D

I, III e IV, apenas.


E

I, II, III e IV.

#include <stdio.h>


int main(int argc, char** argv) {

int i, j, aux;

int v[] = {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};


for(i = 10 - 1; i >= 1; i--)

for(j = 0; j < i; j++)

if(v[j] > v[j + 1]) {

aux = v[j];

v[j] = v[j + 1];

v[j + 1] = aux;

}


_________ for(i = 0; i < 10; i+)

_______________ printf("%d ", v[i]);


return 0;

}

Considerando o algoritmo acima, implementado na linguagem C, assinale a alternativa correta, quanto à saída produzida do trecho destacado.


A

1 3 5 7 9 2 4 6 8 10


B

10 8 6 4 2 9 7 5 3 1


C

10 9 8 7 6 5 4 3 2 1


D

1 2 3 4 5 6 7 8 9 10

Um Assistente Tecnológico da PRODATER observou que o programa em C


A

solicita que o usuário forneça N+1 (ou seja, 6) valores para o vetor vet. Valores negativos e valores repetidos são rejeitados.


B

utiliza um trecho de código que ordena o vetor vet pelo método da bolha e objetiva levar para as últimas posições os valores maiores.


C

realiza uma busca nos elementos do vetor fornecidos pelo usuário através do método de pesquisa sequencial, e não exige que o vetor esteja ordenado.


D

utiliza o método de pesquisa binária e exige que o vetor esteja ordenado, para localizar valores no vetor. Mas se -1 pertencer ao vetor, este elemento não é encontrado.


E

apresenta erro de compilação, já que não exige que valores negativos sejam impedidos de serem inseridos no vetor e não verifica se a quantidade de elementos é maior que a capacidade do vetor.

Analise o código C++ abaixo.


#include <cstdio>

#include <iostream>

#include <string>

#include <queue>


using namespace std;


int main() {

_______priority_queue< pair<int, string> > pq;

_______pair<int, string> result;


_______pq.push(make_pair(100, "fulano"));

_______pq.push(make_pair(10, "ciclano"));

_______pq.push(make_pair(20, "beltrano"));

_______pq.push(make_pair(100, "geronimo"));


_______while( !pq.empty() ){

_____________result = pq.top();

_____________pq.pop();

_____________printf("(%s: %d)",

___________________((string)result.second).c_str(),

___________________result.first);

_______}


_______return 0;

}


Considerando as filas e suas variações, a saída do código C++ acima é


A

(ciclano: 10)(beltrano: 20)(fulano: 100)(geronimo: 100)


B

(beltrano: 20)(ciclano: 10)(fulano: 100)(geronimo: 100)


C

(geronimo: 100)(fulano: 100)(ciclano: 10)(beltrano: 20)


D

(geronimo: 100)(fulano: 100)(beltrano: 20)(ciclano: 10)


E

(geronimo: 100)(fulano: 100)(ciclano: 20)(beltrano: 10)

Na linguagem C, o cabeçalho de biblioteca stdio.h possui definições de subrotinas relativas às operações de entrada/saída padrão. Uma das funções tratadas na biblioteca, associada a esse cabeçalho, é a função:


A

atoi.


B

trunc.


C

scanf.


D

strcpy.


E

locatime.

Na linguagem C#, sempre que o operador new falhar ao alocar memória para um objeto, é lançada a exceção


A

IndexOutOfBoundsException.


B

InsufficientMemoryException.


C

NullReferenceException.


D

OutOfMemoryException.


E

StackOverflowException.

Considere o código abaixo, escrito na linguagem de programação C++.


#include <iostream>

usingnamespacestd;

intmain(){

int A = 0, B = 7, C = 4, D = 3;

for (A = 0; A < B; A++)

D = D + 1;

for (A = 0;A <= C; A++)

D = D + 2;

if (D>=20)

cout<< "SISTEMAS OPERACIONAIS";

else

cout<< "REDES DE COMPUTADORES";

}



Assinale a alternativa que apresenta o valor que a variável D apresentará ao final da execução do programa e qual mensagem aparecerá na tela do computador.


A

D = 15 e “REDES DE COMPUTADORES”.


B

D = 20 e “SISTEMAS OPERACIONAIS”.


C

D = 18 e “REDES DE COMPUTADORES”.


D

D = 20 e “REDES DE COMPUTADORES”.


E

D = 21 e “SISTEMAS OPERACIONAIS”.

Na linguagem C, considere que as variáveis A e B contenham os valores 60 e 13, cujas respectivas representações binárias são mostradas a seguir.


A = 0011 1100

B = 0000 1101


Nesse caso, as expressões


A&B

A|B


têm por valores, respectivamente:


A

0011 1101 e 0000 1100;


B

0011 1100 e 0011 1101;


C

0000 1101 e 0011 1100;


D

0000 1100 e 0011 1101;


E

0000 0000 e 0011 1101.

Considere o trecho de código abaixo, escrito na linguagem de programação C++, que define uma classe chamada Pessoa.


class Pessoa

{

public:

char nome[45];

char sexo;

intanoNascimento;

private

float salario;

private

voidcalcularAumento();


public:

intcalcularIdade (int ano);

}


Sobre a definição acima, assinale a alternativa correta.


A

O método calcularAumento é público.


B

O método calcularIdade é público.


C

O atributo anoNascimento é privado.


D

O atributo salario é público.


E

O atributo nome é privado.

A linguagem de programação C# oferece as interfaces IEquatable<T> e IComparable<T> para que objetos possam ser comparados com outros objetos. A diferença entre essas interfaces é que apenas


A

IComparable<T> é capaz de determinar se os objetos são diferentes.


B

IComparable<T> permite que seja estabelecida uma relação de ordem entre os objetos.


C

IComparable<T> pode ser utilizada para comparar objetos de classes diferentes.


D

IEquatable<T> é capaz de determinar se os objetos são iguais.


E

IEquatable<T> permite que seja estabelecida uma relação de ordem entre os objetos.

Observe o código em linguagem C abaixo.


#include <stdio.h>

#include <stdlib.h>


int main (void) {

int n, i, j, m;

while(1) {

scanf("%d", &n);

if (n<l) return 0;

int vet [n+l];

vet[0]=0;

vet[l]=0;

for(i = 2; i < = n ; i++) vet [i] = i;

for(i = 2; i < = n ; i++) {

for(j = 2; j < = n ; j++) {

if (vet [i] > 0) m = i * j;

if (m>n) break;

vet [m] = 0;

}

}

printf ("\n");

for(i=2;i<=n;i++) {

if(vet[i]>0) printf("%d,",vet[i]);

} printf ("\n");

}

return 0;

}

Com base no código acima, se for digitado 100 para o valor de n, pode-se afirmar que o programa:


A

não mostra nada.


B

é um gerador de números aleatórios que não podem ser previstos.


C

mostrará todos os números primos entre O e 100.


D

mostrará todos os números entre O e 100.


E

mostrará todos os números entre 2 e 100.

Utilizando a linguagem de programação C++, foi definida uma classe Empregado em empregado.hpp. Nessa definição, é encontrada a seguinte linha de comando:


virtualfloatcalculaSalario();


Assinale a alternativa que apresenta a propriedade da orientação a objetos implementada utilizando esse comando e o que essa linha de comando indica.


A

Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação opcional desse método, mas conforme a sua necessidade.


B

Encapsulamento e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, mas conforme a sua necessidade.


C

Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, mas conforme a sua necessidade.


D

Encapsulamento e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação opcional desse método, mas conforme a sua necessidade.


E

Polimorfismo e a linha de comando indica que cada classe filha dessa classe vai ter uma implementação obrigatória desse método, exatamente como ele foi declarado na classe mãe.

Considere os termos private / protected, usados para especificar os direitos de acesso aos membros de classes escritas na linguagem C++. Na ordem respectiva, esses termos denotam permissões de acesso que se limitam aos membros:


A

da mesma classe / da mesma classe e de classes derivadas;


B

da mesma classe / de classes derivadas que sejam protected;


C

da mesma classe que não sejam public / de classes derivadas que não sejam public;


D

de classes derivadas que sejam private / da mesma classe;


E

da mesma classe e de classes derivadas / da mesma classe.

   
Gerar simulado