XI-CS-QUESTION BANK
CLASS – XI QUESTION BANK CS
1.
State major new
changes done during 2nd generations of computers.
2. State
featuresof 1st generations of
computers.
3. State
featuresof 3rd generations of
computers.
4. What
are different type of softwares. Give 5 examples of each type of softwares.
5. Explain
and write Full form of the following terms –
ASCII, ENIAC, ISCII, RISC Processors, EPIC, CISC Processors
6.
Write short note
on the following Open
Source Concepts:
Open Source Software, Freeware, Shareware, Proprietary
Software.
7.
Explain the following Memory Concepts: Units: Byte, Kilo Byte, Mega Byte, Giga Byte, Tera
Byte, Peta Byte, Exa Byte, Zetta Byte, Yotta Byte.
8.
Explain
and find Differentiate between Cache, RAM, ROM
9. Perform the following conversions
(i) (625.375)10=(?)8
(ii) (10011110.110011)2=(?)16
(iii) (3ABFE.4B2)16=(?)10
(iv) (55.678)10=(?)8
(v) (10010.1111)2=(?)8
(vi) (45CAE.4DE2)16=(?)8
(vii) (625.375)10=(?)4
(viii) (10011110.110011)2=(?)8
(ix) (3ABFE.4BCD2)16=(?)4
(x)
(12345.25)10=(?)8
10. What
is OOP? What is difference between Procedural Programming and Object Oriented
Programming ?
11. Explain
the following in terms of OOP:
(A) CLASS
(B) OBJECT (C) POLYMORPHISM (D) Data Abstraction ( E ) Inheritance
12. .
What is special thing about main() function ? What are its rolls?
13. .What
is identifier? What is the naming convention for the identifiers ?
14. Identify
valid and invalid identifiers and justify your answer also .
Minus 3ABC int INT _SUM
printf scanf _sum _float pow num^2 $sum
num 1 ram.shyam salry_max
15. What are the implicit type conversion rules in C++ when adding,
multiplying, etc. Fill “?”
int + float = ?
int * float = ?
float * int = ?
int / float = ?
float / int = ?
int / int = ?
int ^ float = ?
16. Explain
the difference between type promotion and type casting with suitable example code.
17. Find
he output of the following
void main()
{ int
camel=15,cow=33;
cout<<( camel ++)*b – camel
<<endl;
cout<<( cow ++)*(-- camel)<<endl;
}
18. Find
he output of the following
void main()
{ int c=10,d=30;
cout<<( ++d)*b – c<<’\t’;
cout<<( d++)*(-- d)<<’\t’;
cout<<( d --)*b – c<<’\t’;
cout<<( +++d)*(-- d);
}
19. In
the following program , find the correct possible outputs(s) form the given
options :
#include<iostream.h>
#include<stdlib.h>
Void main()
{
Randomize();
Char places[][20]={“VARANASI”,
”VIZAG”, ”KANPUR”, ”AGRA”};
Int city;
For(int i=0 ; i<=2;i++)
{
city =random(2) + 1;
Cout<<places[city]<<”@@”;
}
}
Output :
(i) VIZAG @@ KANPUR @@VIZAG ii)
VARANASI @@ VIZAG@@KANPUR
iii)
VIZAG@@KANPUR@@AGRA iv)
VIZAG@@KANPUR@@KANPUR
20. Rewrite
the code after removing errors. Underline each correction
#include<iostream.h>
void
main()
{ int
n1,n2,n3,avg;
cout<"\nEnter
three numbers ";
cin>>n1,n2,n3;
sum=n1+n2+n3;
avg=sum/3
cout<<"Average
of three numbers is "<<avg;
}
21. Write a program to find area and perimeter of
a circle, a rectangle , a square.
22.
What is escape
sequence? Explain with example?
23. Name the header files which are required for
successful execution of the following c++ code:
void
main( ){
char String[ ] = “String”;
cout << setw(2)<<String;
}
24.
Rewrite the
following program after removing all the syntax error(s), if any]
#include[iostream] // line 1
void
main(){
int
LIST[ ]=[100,200,300,400] , Y; // line
2
COUNT=
4; // line 3
cin>>Y;
for(i=COUNT-1
; I >=0;,i--)
switch(i) {
case
0 :
case
2 : cout<<Y*LIST[i]<endl; //
line 4
break;
case
1:
case
3 : cout >> Y+LIST[i];
}
}
25. Explain
Robustness?
26. Explain different types of errors with
example.
27. What is purpose of comments in a program?
28. What is a Self-documenting code? How documentations
are useful?
29. What is system maintenance? How many different
types of maintenance?
30. .
Explain different types of programming paradigm in details.
31. Name the header
files to which the following belong:
(i) abs( ) (ii)
random( )
32.
Rewrite the following program after removing
all the syntax error(s), if any #include<iostream.h>
void main( )
{ F = 10, S = 20;
test(F;S);
test(S); }
void test(int x, int y = 20)
{ x=x+y;
count<<x>>y;}
33. Write the output of the following
program
#include<iostream.h>
#include<conio.h>
void main( )
{ long NUM=1234543;
int F=0,S=0;
do{ int R=NUM % 10;
if (R %2 != 0)
F += R;
else
S += R;
NUM /= 10;
} while (NUM>0);
cout<<(F-S);
getch();
}
34.
Rewrite the
following code using conditional operator.
if (age>=18)
cout<<"Major";
else
cout<<"Minor";
35. Give
the output of the following code
void main()
{ int
x,y;
for(x=1; x<=4; x++)
{ for(y=1; y<=x; y++)
cout<<x<<y<<"
";
cout<<endl;
}
}
36.
Write a program to display 2, 4, 8, 16,
32,….,1024.
37.
Name the header file to be used for the functions clrscr() and strcpy().
38.
Differentiate between Call by Value and
Call by Reference with suitable code.
39.
Find the possible output(s) of the
following code. Also write the minimum and maximum value of r. void main()
{ int n=4, r,i;
randomize();
r=random(n)+120;
for(i=r; i<125; i++)
cout<<i<<",";
}
(i) 120,121,122,123, (ii)122,123,124,125, (iii) 121,122,123,124, (iv)123,124,
40. Observe the following
program GUESS.CPP carefully, if the
value of variable Num entered by the
user is 5 , choose the correct possible output(s) from the options from (i) to
(iv) and justify your option: (2)
// Program Name : GUESS.CPP
#include<stdlib.h>
#include<iostream.h>
#include<conio.h>
void main()
{
randomize();
int Num,rndnum;
cin>>Num;
rndnum=random(Num)+5;
for(int N=1;N<=rndnum;N++)
cout<<N<<"##";
getch();
}
Output :
(i)1##2##3##4##
(ii)1##2##
(iii)1##2##3##4##5##6##7##8##9##
(iv)1##2##3##
41.
Write a program to check if a given number is a prime number or not?
42.
Find the output of the following code
snippet :
char str[]="NAUSENABAUGH@VIZAG";
int i, j;
for(i=0; str[i]!='\0';
i++)
{ for(j=0;
j<=i; j++)
cout<<str[j];
cout<<endl;
}
43. Write a functions FIND_MAX(int a[] , int n )
that returns the maximum value stored in array.
44. Find size of an 2-D array matrix[15][25] when each element is having 8
bytes.
45. Write user defined functions to
implement toupper(), tolower().
46. Write a program to perform operations on 2 D
matrices (ADD, SUB, TRANSPOSE)
47. Define a structure PERSON with the following descriptions [4]
AADHARno
, Name , RESIDENCE PLACE , PROFESSION , DOB, GENDER
Declare
an array of the PERSON structure to
store details of 30 persons and display
them.
**************************THE
END ***************************
DISTRIBUTION
OF MARKS (UNIT-WISE)
|
Unit No.
|
Unit Name
|
Total Marks
|
|
I
|
COMPUTER FUNDAMENTALS
|
10
|
|
II
|
INTRODUCTION TO C++
|
14
|
|
III
|
PROGRAMMING METHODOLOGY
|
12
|
|
IV
|
PROGRAMMING
IN C++
|
34
|
|
|
|
70
|
BLUEPRINT
|
Unit No.
|
Unit Name
|
VSA(1)
|
VSA(2)
|
SA(3)
|
LA(4)
|
Total Marks
|
|
I
|
COMPUTER FUNDAMENTALS
|
3(3)
|
4(2)
|
3(1)
|
-
|
10
|
|
II
|
INTRODUCTION TO C++
|
1(1)
|
10(5)
|
3(1)
|
-
|
14
|
|
III
|
PROGRAMMING METHODOLOGY
|
2(2)
|
6(3)
|
-
|
4(1)
|
12
|
|
IV
|
PROGRAMMING
IN C++
|
3(3)
|
6(3)
|
9(3)
|
16(4)
|
34
|
|
|
Total
|
9(9)
|
26(13)
|
15(5)
|
20(5)
|
70
|
Note:Within
bracket indicates number of questions, outside bracket indicates marks
***************REFERENCE
STUDY MATTER***********************
If either is long double the other is promoted to long double
If either is double the other is promoted to double
If either is float the other is promoted to float
If either is long long unsigned int the other is promoted to long long unsigned int
If either is long long int the other is promoted to long long int
If either is long unsigned int the other is promoted to long unsigned int
If either is long int the other is promoted to long int
if either is unsigned int the other is promoted to unsigned int
If either is int the other is promoted to int
Both operators are promoted to int
Note. The minimum
size of operations is int. So short/char are promted to int before the
operation is done In all your expressions the int is promoted to a float before
the operation is performed. The result of the operation is a float.
int + float => float + float = float
int * float => float * float = float
float * int => float * float = float
int / float => float / float = float
float / int => float / float = float
int / int = int
int ^ float => <compiler error>
|
down vote
|
Whole chapter 4 talks about conversions, but I think you should be
mostly interested in these :
4.5 Integral promotions [conv.prom]
An rvalue of type char, signed char, unsigned char, short int, or unsigned short int can be converted to an rvalue of type int if int can represent all the values of the source type; other- wise, the source rvalue can be converted to an rvalue of type unsigned int. An rvalue of type wchar_t (3.9.1) or an enumeration type (7.2) can be converted to an rvalue of the first of the following types that can represent all the values of its underlying type: int, unsigned int, long, or unsigned long. An rvalue for an integral bit-field (9.6) can be converted to an rvalue of type int if int can represent all the values of the bit-field; otherwise, it can be converted to unsigned int if unsigned int can rep- resent all the values of the bit-field. If the bit-field is larger yet, no integral promotion applies to it. If the bit-field has an enumerated type, it is treated as any other value of that type for promotion purposes. An rvalue of type bool can be converted to an rvalue of type int, with false becoming zero and true becoming one. These conversions are called integral promotions.
4.6 Floating point promotion [conv.fpprom]
An rvalue of type float can be converted to an rvalue of type double. The value is unchanged. This conversion is called floating point promotion.
Therefore, all conversions involving float - the result is float.
Only the one involving both int - the result is int : int / int = int
|
|
int nValue1 =
10;
int nValue2 =
4;
float fValue
= float(nValue1) / nValue2;
|
The C style cast can be inherently misused, because
it will let you do things that may not make sense, such as getting rid of a
const or changing a data type without changing the underlying representation.
C++ introduces a new casting operator called static_cast. A static cast
works similarly to the C style cast, except it will only do standard type
conversions, which reduces the potential for inadvertant misuse:
|
1
2
3
|
int nValue1 =
10;
int nValue2 =
4;
float fValue
= static_cast<float>(nValue1) / nValue2
|
Previously, you learned that the value of a
variable is stored as a sequence of bits, and the data type of the variable
tells the compiler how to translate those bits into meaningful values. Often it
is the case that data needs to be converted from one type to another type. This
is called type conversion.
Implicit type conversion is done automatically by the compiler whenever
data from different types is intermixed. When a value from one type is assigned
to another type, the compiler implicitly converts the value into a value of the
new type. For example:
|
1
2
|
double dValue
= 3; // implicit conversion to double value 3.0
int nValue =
3.14156; // implicit conversion to integer value 3
|
In the top example, the value 3 is promoted to a
double value and then assigned to dValue. The compiler will not complain about
doing this. However, some type conversions are inherently unsafe, and if the
compiler can detect that an unsafe conversion is being implicitly requested, it
will issue a warning. In the second example, the fractional part of the double
value is dropped because integers can not support fractional values. Because
converting a double to an int usually causes data loss (making it unsafe),
compilers such as Visual Studio Express 2005 will typically issue a warning.
Other unsafe conversions involve assigning unsigned variables to signed
variables (and vice-versa), and assigning large integers (eg. a 4-byte long) to
integer variables of a smaller size (eg. a 2-byte short).
Warning: Microsoft’s Visual C++ 2005 does not seem
to issue warnings for unsafe signed/unsigned conversions.
When evaluating
When evaluating expressions, the compiler breaks
each expression down into individual subexpressions. Typically, these
subexpressions involve a unary or binary operator and some operands. Most
binary operators require their operands to be of the same type. If operands of
mixed types are used, the compiler will convert one operand to agree with the
other. To do this, it uses a heirarchy of data types:
Long double (highest)
Double
Float
Unsigned long int
Long int
Unsigned int
Int (lowest)
Double
Float
Unsigned long int
Long int
Unsigned int
Int (lowest)
For example, in the expression 2 + 3.14159, the +
operator requires both operands to be the same type. In this case, the left
operand is an int, and the right operand is a double. Because double is higher
in the heirarchy, the int gets converted to a double. Consequently, this
expression is evaluated as 2.0 + 3.14159, which evaluates to 5.14159.
A good question is, “why is integer at the bottom
of the tree? What about char and short?”. Char and short are always implicitly
promoted to integers (or unsigned integers) before evaluation. This is called widening.
This heirarchy can cause some interesting issues.
For example, you might expect the expression 5u - 10 to evalute to -5 (5u means
5 as an unsigned integer). But in this case, the signed integer (10) is
promoted to an unsigned integer, and the result of this expression is the
unsigned integer 4294967291!
Many mixed conversion work as expected. For
example, int nValue = 10 * 2.7 yields the result 27. 10 is promoted to a float,
10.0 * 2.7 evaluates to 27.0, and 27.0 is truncated into an integer (which the
compiler will complain about).
Many binary operators
that expect operands of arithmetic or enumeration type cause conversions and
yield result types in a similar way. The purpose is to yield a common type, which
is also the type of the result.
This pattern is called
the usual arithmetic conversions, which are defined as follows:
— If either operand is of
type long double, the other shall be converted to long double.
— Otherwise, if either
operand is double, the other shall be converted to double.
— Otherwise, if either
operand is float, the other shall be converted to float.
— Otherwise, the integral
promotions (4.5) shall be performed on both operands.54)
— Then, if either operand
is unsigned long the other shall be converted to unsigned long.
— Otherwise, if one
operand is a long int and the other unsigned int, then if a long int can
represent all the values of an unsigned int, the unsigned int shall be
converted to a long int; otherwise both operands shall be converted to unsigned
long int.
— Otherwise, if either
operand is long, the other shall be converted to long.
— Otherwise, if either
operand is unsigned, the other shall be converted to unsigned.
Only the one involving
both int - the result is int : int / int = int
Defining a
symbol name using typedef keyword and defining a macro using #define preprocessor
directive.
Now saying
that, here are a few differences:
With #define you can define constants that can be used
in compile time.
You can also
use #define to declare miniature
find-and-replace Macro functions.
typedef can be used to give
aliases to types (which you could probably do with #define as well), but it's safer because of the
find-and-replace nature of #define constants.
Besides that, you can use forward declaration with typedef which allows you to declare a type that will be used, but isn't yet linked to the file you're writing in.
Besides that, you can use forward declaration with typedef which allows you to declare a type that will be used, but isn't yet linked to the file you're writing in.
|
|
typedef is a C keyword that creates an alias for a type. #define is a pre-processor instruction, that creates a text replacement event prior to compilation. When the compiler gets to the code, the original "#defined" word is no longer there. #define is mostly used for macros and global constants
#define is
handled by the pre-processor (like a cut-and-paste operation) before the
compiler sees the code, and typedef is interpreted by
the compiler.
One of the
main differences (at least when it comes to defining data types) is
that typedef allows for more specific type checking. For
example,
#define
defType int
typedef int tdType
defType x;
tdType y;
Here, the
compiler sees variable x as an int, but variable y as a data type called
'tdType' that happens to be the same size as an int. If you wrote a function
that took a parameter of type defType, the caller could pass a normal int and
the compiler wouldn't know the difference. If the function instead took a
parameter of type tdType, the compiler would ensure that a variable of the
proper type was used during function calls.
Preprocessor
macros ("#define's") are a lexical replacement tool a la
"search and replace". They are entirely agnostic of the programming
language and have no understanding what you're trying to do. You can think of
them as a glorified copy/paste mechanic -- occasionally that's useful, but
you should use it with care.
Typedefs
are a C language feature that lets you create aliases for types. This is
extremely useful to make complicated compound types (like structs and
function pointers) readable and handlable (in C++ there are even situations
where you must typedef a type).
Example program for #define, #include preprocessors in C:
#include <stdio.h>
#define height 100
#define number 3.14
#define letter 'A'
#define letter_sequence "ABC"
#define backslash_char '\?'
void main()
{
printf("value of height
: %d \n", height );
printf("value of number : %f \n", number );
printf("value of letter : %c \n", letter );
printf("value of letter_sequence : %s \n", letter_sequence);
printf("value of backslash_char
: %c \n", backslash_char);
}
Output:
http://fresh2refresh.com
|
The #define
Preprocessor Directive: Symbolic Constants
§
The #define directive creates symbolic constants, constants that represented
as symbols and macros (operations defined as symbols). The format is as follows:
#define
identifier replacement-text
§
When this line appears in a file, all subsequent occurrences of identifier will be replaced by the replacement-text automatically before the
program is compiled. For example:
#define PI 3.14159
§
Replaces all subsequent occurrences of the symbolic constant PI with the numeric constant 3.14159. const type qualifier also can be used to declare numeric constant that
will be discussed in another Module.
§
Symbolic constants enable the programmer to create a name for a
constant and use the name throughout the program, the advantage is, it only
need to be modified once in the #define directive, and when the program is recompiled, all occurrences of
the constant in the program will be modified automatically, making writing the
source code easier in big programs.
§
That means everything, to the right of the symbolic constant name
replaces the symbolic constant.
§
Other #define examples include the stringizing as shown below:
#define STR
"This is a simple string"
#define NIL
""
#define GETSTDLIB
#include <stdlib.h>
#define HEADER "myheader.h"
The #define Preprocessor Directive: Macros
§
A macro is an operation defined in #define preprocessor directive.
§
As with symbolic constants, the macro-identifier is replaced in the program with the replacement-text before the program is
compiled. Macros may be defined with or without arguments.
§
A macro without arguments is processed like a symbolic constant while a macro with arguments, the
arguments are substituted in the replacement text, then the macro is expanded,
that is the replacement-text replaces the identifier and argument list in the
program.
§
Consider the following macro definition with one argument for a
circle area:
#define CIR_AREA(x) PI*(x)*(x)
§
Wherever CIR_AREA(x) appears in the file, the value of x is substituted for x in the replacement text, the symbolic
constant PI is replaced by its value (defined previously), and the macro is
expanded in the program. For example, the following statement:
area = CIR_AREA(4);
§
Is expanded to:
area = 3.14159*(4)*(4);
§
Since the expression consists only of constants, at compile time,
the value of the expression is evaluated and assigned to variable area.
§
The parentheses around each x in the replacement text, force a proper order of evaluation when
the macro argument is an expression. For example, the following
statement:
area = CIR_AREA(y + 2);
§
Is expanded to:
area = 3.14159*(y + 2)*(y +
2);
§
This evaluates correctly because the parentheses force the proper
order of evaluation. If the parentheses are omitted, the macro expression
is:
area = 3.14159*y+2*y+2;
§
Which evaluates incorrectly (following the operator precedence
rules) as:
area = (3.14159 * y) + (2 *
y) + 2;
§
Because of the operator precedence rules, you have to be careful
about this.
§
Macro CIR_AREA could be defined as a function. Let say, name it a circleArea:
double circleArea(double x)
{
return (3.14159*x*x);
}
§
Performs the same calculation as macro CIR_AREA, but here the overhead of a function call is associated with circleArea function.
§
The advantages of macro CIR_AREA are that macros insert code directly in the program, avoiding
function overhead (creating
and dismantling the stack), and the program remains readable because
the CIR_AREA calculation is defined separately and named meaningfully.
The disadvantage is that its argument is evaluated twice. Another better
alternative is using the inline function, by adding the inline keyword.
inline double circleArea(double x)
{
return (3.14159 * x * x);
}
§
The following is a macro definition with 2 arguments for the area
of a rectangle:
#define RECTANGLE_AREA(p, q)
(p)*(q)
§
Wherever RECTANGLE_AREA(p, q) appears in the program, the values of p and q are substituted in
the macro replacement text, and the macro is expanded in place of the macro
name. For example, the statement:
rectArea =
RECTANGLE_AREA(a+4, b+7);
§
Will be expanded to:
rectArea = (a+4)*(b+7);
§
The value of the expression is evaluated and assigned to variable rectArea.
§
If the replacement text for a macro or symbolic constant is longer
than the remainder of the line, a backslash (\) must be placed at the end of the line indicating that the
replacement text continues on the next line. For example:
#define RECTANGLE_AREA(p, q) \
(p)*(q)
§
Symbolic constants and macros can be discarded by using the #undef preprocessor
directive. Directive #undef, undefine a symbolic
constant or macro name.
§
The scope of a symbolic constant or macro is from its definition
until it is undefined with #undef, or until the end of the
file. Once undefined, a name can be redefined with#define.
§
Functions in the standard library sometimes are defined as macros
based on other library functions. For example, a macro commonly defined
in the stdio.h header file is:
#define
getchar() getc(stdin)
§
The macro definition of getchar() uses function getc() to get one character from the standard input stream. putchar() function of the stdio.h header, and the character
handling functions of the ctype.h header implemented as macros as well.
§
A program example.
#include <iostream>
#define
THREETIMES(x) (x)*(x)*(x)
#define
CIRAREA(y) (PI)*(y)*(y)
#define
REC(z, a) (z)*(a)
#define
PI 3.14159
int main(void)
{
float p
= 2.5;
float r
= 3.5, s, t, u = 1.5, v = 2.5;
cout<<"Power to three of "<<p<<" is
"<<THREETIMES(p)<<endl;
cout<<"Circle circumference = 2*PI*r =
"<<(2*PI*r)<<endl;
s =
CIRAREA(r+p);
cout<<"Circle area = PI*r*r = "<<s<<endl;
t =
REC(u, v);
cout<<"Rectangle area = u*v = "<<t<<endl;
return
0;
}
[THE END]
