C++ Programming Code Examples
C++ > Algorithms Code Examples
Universal image format convertion
/* Universal image format convertion */
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef unsigned char uchar;
struct UlFormatData
{
public:
int BytesPP;
ulong BitMask[4]; // A bit mask in source A8R8G8B8 picture.
int ShiftR[4]; // Can be < 0 for left shift operation.
public:
ulong CreateBitMask(int aStartPosition, int aSize)
{
ulong result = 0;
UlFor (int i = 0; i < aSize; i++)
{
result = (result >> 1) | 0x80000000;
}
result = result >> aStartPosition;
return result;
}
UlFormatData(const char *format_str)
{
BytesPP = 0;
for (int i = 0; i < 4; i++)
{
ShiftR[i] = 0;
BitMask[i] = 0; // Exclude color if not in use.
}
// Count destination's bits per pixel.
int bitsPP = 0;
UlFor (const char *temp = format_str; *temp; temp++)
{
if ('0' <= *temp && *temp <= '9')
bitsPP += *temp - '0';
}
// Main loop: trace format_str and calculate masks and shifts.
int bitsPassed = 0;
int currentIndex = 0; // Index for any 'argb' order.
while (*format_str)
{
char color = *(format_str++);
char numberOfBits = *(format_str++) - '0';
int sourceColorStart =
color == 'A' || color == 'X' ? 0 :
color == 'R' ? 8 :
color == 'G' ? 16 :
color == 'B' ? 24 : 32;
BitMask[currentIndex] = CreateBitMask(sourceColorStart, numberOfBits);
ShiftR[currentIndex] = bitsPassed - sourceColorStart + (32 - bitsPP);
bitsPassed += numberOfBits;
currentIndex++;
}
BytesPP = bitsPP / 8;
}
};
//------------------------------------------------------------------------------
// There is no 24-bit type in C++, so...
struct UlBits24
{
char b[3];
};
//------------------------------------------------------------------------------
// Template function that will copy a line of image into destination with
// adequate conversion.
template <class dsttype>
static inline void CopyARGBLine(const ulong *srcline, dsttype *dstline,
const UlFormatData &aFormatData, int width)
{
for (int x = 0; x < width; x++)
{
ulong temp = *(srcline++);
ulong result = 0;
UlFor (int i = 0; i < 4; i++)
{
result |= ((temp & aFormatData.BitMask[i]) >>
aFormatData.ShiftR[i]);
}
*(dstline++) = *(dsttype *)(&result);
}
}
//------------------------------------------------------------------------------
void ConvertFromA8R8G8B8(const ulong *aSource, int width, int height,
const UlFormatData &aFormatData, uchar *aData, int aPitch)
{
for (int y = 0; y < height; y++)
{
const ulong *line = aSource + (y * width);
uchar *dstline = aData + (y * aPitch);
switch (aFormatData.BytesPP)
{
case 1:
CopyARGBLine<uchar>(line, (uchar *)dstline, aFormatData, width);
break;
case 2:
CopyARGBLine<ushort>(line, (ushort *)dstline, aFormatData, width);
break;
case 3:
CopyARGBLine<UlBits24>(line, (UlBits24 *)dstline,
aFormatData, width);
break;
case 4:
CopyARGBLine<ulong>(line, (ulong *)dstline, aFormatData, width);
break;
default:
throw "Incorrect destination image format";
}
}
}
As the name already suggests, these operators help in assigning values to variables. These operators help us in allocating a particular value to the operands. The main simple assignment operator is '='. We have to be sure that both the left and right sides of the operator must have the same data type. We have different levels of operators. Assignment operators are used to assign the value, variable and function to another variable. Assignment operators in C are some of the C Programming Operator, which are useful to assign the values to the declared variables. Let's discuss the various types of the assignment operators such as =, +=, -=, /=, *= and %=. The following table lists the assignment operators supported by the C language:
Logical Operators are used to compare and connect two or more expressions or variables, such that the value of the expression is completely dependent on the original expression or value or variable. We use logical operators to check whether an expression is true or false. If the expression is true, it returns 1 whereas if the expression is false, it returns 0. Assume variable A holds 1 and variable B holds 0:
In C++, classes and structs are blueprints that are used to create the instance of a class. Structs are used for lightweight objects such as Rectangle, color, Point, etc. Unlike class, structs in C++ are value type than reference type. It is useful if you have data that is not intended to be modified after creation of struct. C++ Structure is a collection of different data types. It is similar to the class that holds different types of data. A structure is declared by preceding the struct keyword followed by the identifier(structure name). Inside the curly braces, we can declare the member variables of different types.
The header file graphics.h contains line() function which is used to draw a line from a point(x1, y1) to point(x2, y2) i.e. (x1, y1) and (x2, y2) are end points of the line. The function line() draws a line on the graphics screen between two specified points. So this function requires four parameters namely x1, y1, x2, and y2 to represent two points. This function draws a line from (x1, y1) coordinates to (x2, y2) coordinates on the graphics screen.
The bitwise operators are the operators used to perform the operations on the data at the bit-level. When we perform the bitwise operations, then it is also known as bit-level programming. It consists of two digits, either 0 or 1. It is mainly used in numerical computations to make the calculations faster. We have different types of bitwise operators in the C++ programming language. The following is the list of the bitwise operators: Bitwise AND operator is denoted by the single ampersand sign (&). Two integer operands are written on both sides of the (&) operator. If the corresponding bits of both the operands are 1, then the output of the bitwise AND operation is 1; otherwise, the output would be 0. This is one of the most commonly used logical bitwise operators. It is represented by a single ampersand sign (&). Two integer expressions are written on each side of the (&) operator.
Switch statement in C tests the value of a variable and compares it with multiple cases. Once the case match is found, a block of statements associated with that particular case is executed. Each case in a block of a switch has a different name/number which is referred to as an identifier. The value provided by the user is compared with all the cases inside the switch block until the match is found. If a case match is NOT found, then the default statement is executed, and the control goes out of the switch block. • The expression can be integer expression or a character expression. • Value-1, 2, n are case labels which are used to identify each case individually. Remember that case labels should not be same as it may create a problem while executing a program. Suppose we have two cases with the same label as '1'. Then while executing the program, the case that appears first will be executed even though you want the program to execute a second case. This creates problems in the program and
Inline function is one of the important feature of C++. So, let's first understand why inline functions are used and what is the purpose of inline function? When the program executes the function call instruction the CPU stores the memory address of the instruction following the function call, copies the arguments of the function on the stack and finally transfers control to the specified function. The CPU then executes the function code, stores the function return value in a predefined memory location/register and returns control to the calling function. This can become overhead if the execution time of function is less than the switching time from the caller function to called function (callee). For functions that are large and/or perform complex tasks, the overhead of the function call is usually insignificant compared to the amount of time the function takes to run. However, for small, commonly-used functions, the time needed to make the function call is often a lot more than the time needed to actually
Templates are powerful features of C++ which allows us to write generic programs. Similar to function templates, we can use class templates to create a single class to work with different data types. Class templates come in handy as they can make our code shorter and more manageable. A class template starts with the keyword template followed by template parameter(s) inside <> which is followed by the class declaration. T is the template argument which is a placeholder for the data type used, and class is a keyword. Inside the class body, a member variable var and a member function functionName() are both of type T.
Break statement in C++ is a loop control statement defined using the break keyword. It is used to stop the current execution and proceed with the next one. When a compiler calls the break statement, it immediately stops the execution of the loop and transfers the control outside the loop and executes the other statements. In the case of a nested loop, break the statement stops the execution of the inner loop and proceeds with the outer loop. The statement itself says it breaks the loop. When the break statement is called in the program, it immediately terminates the loop and transfers the flow control to the statement mentioned outside the loop.
In computer programming, loops are used to repeat a block of code. For example, when you are displaying number from 1 to 100 you may want set the value of a variable to 1 and display it 100 times, increasing its value by 1 on each loop iteration. When you know exactly how many times you want to loop through a block of code, use the for loop instead of a while loop. A for loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times.
Static is a keyword in C++ used to give special characteristics to an element. Static elements are allocated storage only once in a program lifetime in static storage area. And they have a scope till the program lifetime. In C++, static is a keyword or modifier that belongs to the type not instance. So instance is not required to access the static members. In C++, static can be field, method, constructor, class, properties, operator and event. Advantage of C++ static keyword: Memory efficient. Now we don't need to create instance for accessing the static members, so it saves memory. Moreover, it belongs to the type, so it will not get memory each time when instance is created.
In computer programming, we use the if statement to run a block code only when a certain condition is met. An if statement can be followed by an optional else statement, which executes when the boolean expression is false. There are three forms of if...else statements in C++: • if statement, • if...else statement, • if...else if...else statement, The if statement evaluates the condition inside the parentheses ( ). If the condition evaluates to true, the code inside the body of if is executed. If the condition evaluates to false, the code inside the body of if is skipped.
In while loop, condition is evaluated first and if it returns true then the statements inside while loop execute, this happens repeatedly until the condition returns false. When condition returns false, the control comes out of loop and jumps to the next statement in the program after while loop. The important point to note when using while loop is that we need to use increment or decrement statement inside while loop so that the loop variable gets changed on each iteration, and at some point condition returns false. This way we can end the execution of while loop otherwise the loop would execute indefinitely. A while loop that never stops is said to be the infinite while loop, when we give the condition in such a way so that it never returns false, then the loops becomes infinite and repeats itself indefinitely.
A C++ template is a powerful feature added to C++. It allows you to define the generic classes and generic functions and thus provides support for generic programming. Generic programming is a technique where generic types are used as parameters in algorithms so that they can work for a variety of data types. We can define a template for a function. For example, if we have an add() function, we can create versions of the add function for adding the int, float or double type values. Where Ttype: It is a placeholder name for a data type used by the function. It is used within the function definition. It is only a placeholder that the compiler will automatically replace this placeholder with the actual data type. class: A class keyword is used to specify a generic type in a template declaration.
Program should display every prime number between 'range' and at the end total number of "prime numbers" found in range. Separate function which receives "two parameters" for
Example of using this 'pointer' is to return the "Reference of current object" so that you can chain "function calls", this way you can call all the functions for the current object in one go.
To convert octal number to "hexadecimal" in C++, you have to ask to the user to enter the octal number to convert it into hexadecimal to print the equivalent value in hexadecimal
