Computer Programming

In what language?

c and c++

a 5 x 5 array of Int

int nMultiIntArray[5][5];

Answer:

in java

int array[][]=new int[5][5];

in vb

dim array(5,5) as Integer

1's complement and 2's complement relate to the way negative integers are represented in computer memory. With 1's complement, all the bits are inverted. This results in there being two representations for the value 0 because 00000000 is +0 while 11111111 is -0. But in the real world 0 is neither positive nor negative. To resolve this, 2's complement inverts all the bits and then adds 1 ignoring any overflow, such that 11111111 + 00000001 = 00000000.

With 1's complement, the valid range of integers for an 8-bit value is -127 to +127 but with 2's complement it is -128 to +127 because we eliminate the redundant 0 value.

Most modern systems use 2's complement but there are still systems using 1's complement.

function name and arguments

#include<iostream>

#include<time.h>

#include<forward_list>

int main()

{

// seed random number generator

srand ((unsigned) time(NULL));

// a forward_list is a singly-linked list

std::forward_list<int> stack;

// push 10 integers onto stack

for (int loop=0; loop<10; ++loop)

{

int num=rand();

std::cout<<"Pushing "<<num<<std::endl;

stack.push_front (num);

}

// pop all integers

while (!stack.empty())

{

std::cout<<"Popping "<<stack.front()<<std::endl;

stack.pop_front();

}

}

what are the internal diseconomics of scale operation what are the internal diseconomics of scale operation

COE stands for coefficient of expansion. Different glass formulas expand and cool down at different rates. If you mix two incompatible glasses (for casting or fusing art glass projects) the glass will fracture and most likely ruin the project you are working on.

A variable that depends on an instant rather than a flow of time

Easiest way to understand threads is they are lanes on a highway. where data ques up,

Yes, the minimum is the following:

int main (void) { return 0; }

With function system or popen.

There is no "NULL array" as such, you may take a pointer to an array and set it to NULL (binary 0) e.g.

int* foo; // Declare a pointer

foo = malloc( 40 * sizeof(int)); //Allocate an array of 40 integers pointed to by "foo"

foo = NULL; //Set the pointer to NULL, if you're using a garbage collector this should trigger an automatic free() of the memory allocated to the array. If you are NOT using a garbage collector (which is more common in C) this line is a memory leak.

4 th generation computers

All members of a union are assigned the same memory address. As such, assigning to any member of a union changes the value of all members in that union.

The total number of bytes allocated to a union is equal to the length of the largest member of that union. Where the members differ in length, assigning to a member will completely overwrite all the smaller members but will only partially overwrite any larger members.

After assigning a value to a union member, that member is said to be "active". The active member remains active until a value is assigned to another member. However, a union does not keep track of which member is currently active; the onus is entirely upon the programmer to ensure the correct member is accessed.

In some cases, keeping track of the active member is not necessary. For instance, consider the following union:

union u {

int i;

char c[sizeof(int)];

};

This union has two members, both of which are the same length, sizeof(int). We can read and write integer values through the u::i member just as we can any ordinary integer, however the u::c member allows us to read and write the individual bytes within the integer. Since both members are integral types, there is no need to keep track of which member is currently active; it simply provides two methods of accessing the same memory. Thus if we need to access a multi-byte value at the byte level, a union provides the most intuitive method of achieving it without resorting to type casting a pointer.

Where members differ in size, we often need to keep track of which member is active. One method of achieving this is by embedding the union in a struct along with an enum member to keep track of the active member of the union:

typedef enum a_t {num, arr} a;

union u {

int number;

int* array;

};

struct s {

u data;

a active;

};

In the above example, we can choose to store a single value in s::u::number or we can choose to store multiple values in the memory pointed to by s::u::array. However, if we store a value in s::u::number and then attempted to dereference the s::u::array pointer, we incur undefined behaviour because a) an int and a pointer (to any type) are not guaranteed to be the same length and b) the number may not contain a valid address.

Therefore it is important that whenever we write to s::u we update s::a to reflect which member was written to and we must read s::a before accessing s::u. In addition, we must be sure to release any resources currently allocated to the s::u::array before assigning a new value to s::u.

In this example we don't actually gain any benefit by using a union because we end up using just a much memory as we would if the two members were allocated to separate addresses, because of the need to keep track of the active member. However, if the union has three or more members, we begin to save memory because all the "inactive" members cost nothing.

If the design is poorly done, the construction and implementation phases will be significantly slowed down. The programmers will find themselves constantly clarifying erroneous or incomplete design specifications. Users may find that the delivered system doesn't fulfill the requirements that were agreed upon during systems analysis.

The lifetime costs of the system will be exceeded since considerable maintenance costs will likely be incurred to correct the design deficiencies.

Low levels of thyroxine, or hypothyroidism, can lead to various symptoms including fatigue, weight gain, and depression. It can also cause dry skin, hair loss, and sensitivity to cold. Severe cases may result in more serious complications, such as myxedema coma, which is a life-threatening condition. Common causes of low thyroxine levels include autoimmune diseases like Hashimoto's thyroiditis, iodine deficiency, and certain medications.

A Spike is a sudden increase in voltage that lasts for a very short period and exceeds 100% of the normal voltage on a line. Spikes can be caused by lightning strikes, but can also occur when the electrical system comes back on after a blackout.

if u have itunes version 7 or higher then it needs xp service pack 2..but if u dont have it u can download it free from Microsoft website it free..or try downloading an older version like itunes version 6 or lower

The constructor of a class is automatically called when an instance of the class is created (using new in C++). The constructor method has the same name as the class that it is a part of. Constructors have no type and do not return anything.

Similarly, the destructor is automatically called when the instance of the class is destroyed. The destructor is the same name as the class and is preceded by a tilde (~)

For example:

class Example

{

public:

Example() // Constructor

{

printf("Object created\n");

}

~Example() // Destructor

{

printf("Object destroyed\n")

} };

int main()

{

Example* x = new Example(); // Creates object, calls constructor

delete x; // Calls destructor, deletes object

return 0;

}

Incoming server can refer to the mail server your mail client accesses for email.

The concept of a logical address space is simply involved the process of mapping the Logical addresses to their Physical Addresses . Logical addresses are generated by the CPU; also referred to as virtual addresses.while Physical Address is the actual address of the data stored on the physical device and mapped by MMU.

True, a variable cannot be both global and local. But if a global and a local variable share the same name, the local one will hide the global.

Yes, in fact, they are always mixed. You always write structured procedures (the main function, at least), that will control your objects. Objects can't work just by themselves. At least, that's how it is in C++.

Yes. It's analogous with the Trojan Horse story from Greek mythology, where the Trojans secrete themselves within a large wooden horse left as a "gift" to the Greeks, thus gaining entry to the Greek stronghold. A Trojan program works the same way. The "gift horse" relies on social engineering to entice you to install the payload upon your system by offering you a popular software package for free. Torrent websites are a common source of Trojans -- for obvious reasons.