C++ Programming

x = 12;

The sum of 2 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 plus 0 equals 2.

1 + 44 + 5 - 50 = 0

100 + 7 = 107

78 + 25 = 103

Control instructions are instructions that alter the flow of execution. In C++ this include if, if-else statements, switch-case statements and the conditional ternary operator (?:), as well as loop structures (for, while, do-while) and procedural goto statements.

c = 12.25

To obtain the last whole digit of a number, use the modulo (%) of the number and 10. The modulo evaluates to the remainder after division. Thus 15%10 returns 5 because 15 divided by 10 is 1 remainder 5. Therefore the last digit of any integer, n, is therefore n%10. The same trick can be used to find the last digit for any base, where n is a base 10 integer. Thus n%8 will return the last octal digit, while n%16 will return the last hexadecimal digit.

The chemical equation representing the reaction of magnesium (Mg) with oxygen (O2) to form magnesium oxide is: 2Mg + O2 → 2MgO The "c" in your equation does not have a clear designation in this context.

Static binding is where the linker copies the referenced module into the executable image of the program at compilation/link time. The referenced module becomes a part of the executable image. Dynamic binding is where the linker copies only a stub code for the referenced module into the executable image. That stub code loads the referenced module into memory at load/run time. Advantage of static is simplicity. The executable is stand-alone. Disadvantage is the executable image is larger, and if the referenced module changes, then each executable that uses it must be relinked. Another disadvantage is that if you have more than one executable using the module at the same time, you must have multiple copies of it in memory. Advantage of dynamic is reduced size of the executable image and that changing the referenced module does not require relink of the executable. Another advantage is that most operating systems can share the referenced module, meaning that only one copy of the referenced module need exist in all of memory for any number of references to that module, such as from multiple instances of the executable. Disadvantage of dynamic is that the executable is dependent on the shared library at run time. Another disadvantage is that, since the module is shared, it must be reentrant and thread safe, and this is not always done correctly.

BAC (Bacterial Artificial Chromosome) arrays are a type of DNA arrays. BAC arrays are usually used for a technique called array CGH (Comparative Genomic Hybridisation) which is used to identify gross deletions or amplifications in DNA (which for example is common in cancer). DNA arrays include BAC arrays but also oligo, cDNA, and promoter arrays. Oligo and cDNA arrays are typically used for gene expression analysis (looking to see how heavily expressed each gene is). Oligo arrays can also be used for SNP (single nucleotide polymorphism) analysis. Promoter arrays are used to identify transcription factor binding sites.

In codominance, neither phenotype is recessive. Instead, the heterozygous individual expresses bothphenotypes. Intermediate inheritance is when neither allele is dominant to another, but a mixture is produced in the 2 alleles present. A mixed phenotype is given that is between the two parents phenotype .e.g Red flowers (RR) crossed with white flowers (WW) produces pink flowers (RW).

Sample profiling involves analyzing a subset of the data (sample) to gain insights into the characteristics and behavior of the entire population. This technique is commonly used in market research, data analysis, and data mining to make inferences and predictions about a larger group based on the sample data. It helps to understand the key attributes, trends, and patterns to make informed decisions.

The main difference between c and c++ is the concept of 'Object Oriented Programming' (OOPS).

Thus c does not have the benefits of oops like:

1. abstraction

2. encapsulation

3. inheritance

4. polymorphism etc.

Traversal simply means moving from one node to the next. Generally one searches by traversing the list, comparing each node's data with a given datum, either to return a pointer to a single matching node, or to return a list of matching nodes (copied from the list being searched), or simply to collect data about the matching nodes (such as a count of all the matching nodes).

//program to find the factorial value f any number using while loop

#include<stdio.h>

void main()

{

int i,n,fact=1;

printf("Enter the number\n");

scanf("%d",&n);

i=n;

while (i>=1)

{

fact=fact*i;

i--;

}

printf("The factorial value=%d",fact);

}

the above is a program for calculating tha factorial value of any number which is entered by the user

The new operator in C++ works in a similar manner to malloc in C, allocating memory from the heap (the free store). However, unlike malloc which returns a void* pointer to uninitialised memory, the new operator returns a pointer of the given type and invokes the appropriate constructor for that type. Moreover, every class of object can overload its new operator to allow construction within memory that has been allocated in advance. That memory is typically allocated through a resource handle (known as an allocator), however we can also override the global new operator if we need to provide our own memory management.

We can still use malloc in C++, however it has no advantages over the new operator and is best avoided in the interests of consistency and, more importantly, type safety. In practice we rarely use the new operator unless we are actually designing our own resource handles or low-level memory allocators. The standard library already provides highly efficient resource handles for the vast majority of our everyday needs, so it is rarely necessary to design our own. Nevertheless, the facility exists for those (very) rare occasions where we really do require "raw" memory.

it cannot be operator overloaded.

Parameters are the formal arguments of a function, as defined by the function. When you pass arguments to a function, those arguments are assigned to the function's parameters, either by value or by reference, depending on how the parameters are declared in the function. The following example explains both:

void foo( int param )

{

// param is a by value parameter, which is a copy of the argument passed to it.

}

void bar( int& param )

{

// param is a reference parameter, which references the argument passed to it.

}

int main()

{

int arg = 100;

foo( arg );

bar( arg );

return( 0 );

}

Note that passing a pointer is the same as passing an int by value: the pointer's value is passed to the function, not the pointer itself. To pass a pointer by reference, you must pass a pointer to pointer and the function's parameter must accept a pointer to pointer.

#include<iostream>

#include<list>

int main()

{

// the linked list (of integers)

std::list<int> List;

// insertions:

List.push_back (42);

List.push_back (99);

List.push_back (60);

List.push_front (55);

// point to first node

std::list<int>::iterator n = List.begin();

// advance to next node

++n;

// insert in front of node n

list.insert (n, 33);

// print list:

for (auto node : List) std::cout << node << std::endl;

}