C Programming

State what the variable represents in the equation.

Complexity.

c++

There is no 'Spell' in stdio.h or conio.h

Arranging characters in alphabetical order is exactly what it sounds like. You must arrange characters in the order that they appear alphabetically.

McDonaldization is a term that describes the the control of a process. In the case of McDonalds, it means the process of making a hamburger, is more controlled and everything comes out the same.

void reverse (char* str) {

char *left, *right, temp;

left = right = str;

while (*right) ++right;

--right;

while (left < right) {

temp = *left;

*left = *right;

*right = temp;

++left;

--right;

}

}

The simplest way is to store the sequence in an array, then pass the array to the following function:

int sum (int* a, int size) {

int s = 0;

for (int i=0; i<size; ++i) s += a[i];

return s;

}

Example usage:

int x[5] = {1, 2, 3, 4, 5};

int s = sum (x, 5);

assert (s == 15);

Linear search is necessary when we must search unordered sets. Linear search times across huge sets can be improved significantly by dividing the set amongst two or more threads that can execute on independent CPU cores.

#include<stdio.h>

#include<conio.h>

#include<string.h>

void main()

{

char str1[]="ravi kant yadav";

char str2[20],*p1,*p2;

clrscr();

p1=str1+strlen(str1)-1; //Make p1 point to end of str1.

p2=str2;

while(p1>=str1)

*p2++=*p1--;

*p2='\0';

printf("Original string=%s. Reversed String=%s",str1,str2);

getch();

}

On your computer.

Virtual inheritance is used in multiple inheritance hierarchies whenever two or more classes inherit from the same base class. For example, consider the following minimal example:

struct A {int x;};

struct B : A {};

struct C : A {};

struct D : B, C {};

Here, A is a common base class of both B and C, thus B::A and C::A are independent instances of A. However, D inherits from both B and C thus indirectly inherits both B::A and C::A. This introduces an ambiguity when implicitly referring to A from D, as in the following example:

D d; d.x = 42; // error: ambiguous

When the compiler sees this it won't know whether we are referring to B::A.x or C::A.x, thus we must be explicit when referring to A via D:

d.B::x = 42; // ok

The problem with this is that we still have two separate instances of x so unless we are extremely careful about which x we are referring to we can easily end up with two different values for x with no way of knowing which was the correct value with respect to D.

What we really need is for B and C to share the same instance of A and we achieve that through virtual inheritance:

struct A {int x;};

struct B : virtual A {};

struct C : virtual A {};

struct D : B, C {};

D d;

d.x = 42; // ok

Note that d.x can be referred to as d::A.x, d::B::A.x or d::C::A.x because they all refer to the same instance of x, thus the ambiguity is eliminated. In effect, the most-derived class in the hierarchy (D) is now a direct descendant of A rather than an indirect descendant of both B::A and C::A.

Note also that the virtual keyword has no effect on independent instances of either B or C because they then become the most-derived classes within their own hierarchy and therefore behave exactly as they would had the virtual keyword been omitted. The virtual keyword only comes into play when we derive from a class with a virtual base.

It is also possible to have a base class that is both virtual and non-virtual in the same hierarchy:

struct A {int x;};

struct B : virtual A {};

struct C : virtual A {};

struct D: A {}

struct E : B, C, D {};

Here, A is a virtual base of both B and C, as before, but not of D. Thus E::A implicitly refers to the virtual A while E::D::A must be explicitly referred to as E::D::A because it is a separate instance. Such classes are best avoided, but if we don't have access to the source code we sometimes don't have a choice in the matter.

However, if a base class holds no data it really doesn't matter whether it is declared virtual or not because a class that has no data consumes just one byte regardless of how many instances there are.

#include<stdio.h>

#include<conio.h>

main()

{

int n,max=0,rem;

printf("\n enter a number");

scanf("%d",&n);

while(n!=0)

{

rem=n%10;

n=n/10;

if(rem>max)

{

max=rem:

}}

printf("\n the largest digit is: %d",max);

getch();

}

It is any of the operators used to compare things to see if they are equal or greater than to less than etc. So ones like > < = are all comparison operators.

#include<stdio.h>

#include<conio.h>

void main()

{

int n;

clrscr();

printf("\n enter the number:");

scanf("%d",&n);

if(n%2==0)

printf("\n the number is even");

getch();

}

fe3+

void abc(int); is a function declaration. The declared function has no return value, is named abc and accepts one integer argument by value.

To return multiple values of the same type, return an array. If the values are different types, return a tuple or data structure. To return values indirectly, return a pointer to the results (arrays implicitly convert to pointers, but tuples and data structures do not). A returned pointer must never refer to a local variable of the returning function; upon return, those variables will cease to exist, resulting in undefined behaviour. To avoid this, the caller may provide a user-defined storage location via an output argument, or the function may allocate the return values on the free store (the heap).

Sequential search is the only way to search an unsorted array unless you resort to a multi-threaded parallel search where all threads concurrently search a portion of the array sequentially.

Short answer: Four

A much more precise answer: The IDE standard allows for two devices to share a single IDE channel. The most common configuration is for there to be two IDE channels on the motherboard, allowing for a total of four devices. It is possible however, to add more IDE channels, usually in the form of PCI add-on IDE controller cards and have literally dozens of IDE devices in a single computer system.

Dynamic queue is one that can grow to allow for more entries.

àA static queue has a fixed number of slots and once they are full no more entries can be supported until one entry leaves the queue.