Registers
The main tools to write programs in x86 assembly are the processor registers. The registers are like variables built in the processor. Using registers instead of memory to store values makes the process faster and cleaner. The problem with the x86 series of processors is that there are few registers to use.
Modern x86 processors have eight 32-bit general-purpose registers, as depicted in the figure below. The register names are mostly historical. For example, EAX used to be called the accumulator since it was used by a number of arithmetic operations, and ECX was known as the counter since it was used to hold a loop index. Whereas most of the registers have lost their special purposes in the modern instruction set, by convention, two are reserved for special purposes — the stack pointer (ESP) and the base pointer (EBP). More details are given below.
Here is a list of the available registers on the 386 and higher processors. This list shows the 32 bit registers. Most of the can be broken down to 16 or even 8 bits registers.
General registers
EAX EBX ECX EDX
Segment registers
CS DS ES FS GS SS
Index and pointers
ESI EDI EBP EIP ESP
Indicator
EFLAGS
General registers
As the title says, general register are the one we use most of the time Most of the instructions perform on these registers. They all can be broken down into 16 and 8 bit registers.
32 bits : EAX EBX ECX EDX
16 bits : AX BX CX DX
8 bits : AH AL BH BL CH CL DH DL
The “H” and “L” suffix on the 8 bit registers stand for high byte and low byte. With this out of the way, let’s see their individual main use
EAX,AX,AH,AL : Called the Accumulator register.
It is used for I/O port access, arithmetic, interrupt calls,
etc...
EBX,BX,BH,BL : Called the Base register
It is used as a base pointer for memory access
Gets some interrupt return values
ECX,CX,CH,CL : Called the Counter register
It is used as a loop counter and for shifts
Gets some interrupt values
EDX,DX,DH,DL : Called the Data register
It is used for I/O port access, arithmetic, some interrupt
calls.
Segment registers
Segment registers hold the segment address of various items. They are only available in 16 values. They can only be set by a general register or special instructions. Some of them are critical for the good execution of the program and you might want to consider playing with them when you’ll be ready for multi-segment programming
CS : Holds the Code segment in which your program runs.
Changing its value might make the computer hang.
DS : Holds the Data segment that your program accesses.
Changing its value might give erronous data.
ES,FS,GS : These are extra segment registers available for
far pointer addressing like video memory and such.
SS : Holds the Stack segment your program uses.
Sometimes has the same value as DS.
Changing its value can give unpredictable results,
mostly data related.
Indexes and pointers
Indexes and pointer and the offset part of and address. They have various uses but each register has a specific function. They some time used with a segment register to point to far address (in a 1Mb range). The register with an “E” prefix can only be used in protected mode.
ES:EDI EDI DI : Destination index register
Used for string, memory array copying and setting and
for far pointer addressing with ES
DS:ESI EDI SI : Source index register
Used for string and memory array copying
SS:EBP EBP BP : Stack Base pointer register
Holds the base address of the stack
SS:ESP ESP SP : Stack pointer register
Holds the top address of the stack
CS:EIP EIP IP : Index Pointer
Holds the offset of the next instruction
It can only be read
The EFLAGS register
The EFLAGS register hold the state of the processor. It is modified by many intructions and is used for comparing some parameters, conditional loops and conditionnal jumps. Each bit holds the state of specific parameter of the last instruction. Here is a listing :
Bit Label Desciption
---------------------------
0 CF Carry flag
2 PF Parity flag
4 AF Auxiliary carry flag
6 ZF Zero flag
7 SF Sign flag
8 TF Trap flag
9 IF Interrupt enable flag
10 DF Direction flag
11 OF Overflow flag
12-13 IOPL I/O Priviledge level
14 NT Nested task flag
16 RF Resume flag
17 VM Virtual 8086 mode flag
18 AC Alignment check flag (486+)
19 VIF Virutal interrupt flag
20 VIP Virtual interrupt pending flag
21 ID ID flag
Those that are not listed are reserved by Intel.
Undocumented registers
There are registers on the 80386 and higher processors that are not well documented by Intel. These are divided in control registers, debug registers, test registers and protected mode segmentation registers. As far as I know, the control registers, along with the segmentation registers, are used in protected mode programming, all of these registers are available on 80386 and higher processors except the test registers that have been removed on the pentium. Control registers are CR0 to CR4, Debug registers are DR0 to DR7, test registers are TR3 to TR7 and the protected mode segmentation registers are GDTR (Global Descriptor Table Register), IDTR (Interrupt Descriptor Table Register), LDTR (Local DTR), and TR.
#include<iostream>
using namespace std;
// A recursive binary search function. It returns
// location of x in given array arr[l..r] is present,
// otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l) {
int mid = l + (r - l) / 2;
// If the element is present at the middle
// itself
if (arr[mid] == x)
return mid;
// If element is smaller than mid, then
// it can only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
// Else the element can only be present
// in right subarray
return binarySearch(arr, mid + 1, r, x);
}
// We reach here when element is not
// present in array
return -1;
}
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int x = 10;
int n = sizeof(arr) / sizeof(arr[0]);
int result = binarySearch(arr, 0, n - 1, x);
(result == -1) ? cout << "Element is not present in array"
: cout << "Element is present at index " << result;
return 0;
}
#include<iostream>
using namespace std;
int binarySearch(int arr[], int num, int n)
{
int min = 0;
int max = n-1;
while (min <= max)
{
int mid = (max + (max - min)) / 2;
if (arr[mid] == num)
return mid;
if (arr[mid] > num)
{
max = mid - 1;
}
else
{
min = mid + 1;
}
}
return -1;
}
int main(void)
{
int arr[] = { 1, 2, 3, 4, 10, 40 };
int x = 10;
int n = sizeof(arr) / sizeof(arr[0]);
int result = binarySearch(arr, 10, n);
(result == -1) ? cout << "Element is not present in array"
: cout << "Element is present at index " << result;
return 0;
}
Write a program to reverse a string in C++
There are numerous ways to solve this problem. Let’s start with the simplest one – Using the inbuilt “reverse” function. In the example below, the string to be reversed is initialized within the program to a string variable “greeting”. As a challenge, you can try to implement by prompting the user to Enter the string to be reversed.
reverse() is a predefined function in header file algorithm. It is defined as a template in the above mentioned header file. It reverses the order of the elements in the range [first, last) of any container. The time complexity is O(n). Click here to learn more about reverse().
Â
#include <iostream>
#include <string>
using namespace std;
int main() {
string greeting = "Hello";
reverse(greeting.begin(), greeting.end());
cout << greeting << endl;
}
#include <iostream>
using namespace std;
int main() {
string greeting = "Hello";
int len = greeting.length();
int n=len-1;
for(int i=0;i<(len/2);i++){
//Using the swap method to switch values at each index
swap(greeting[i],greeting[n]);
n = n-1;
}
cout<<greeting<<endl;
}
#include <iostream>
using namespace std;
int main() {
string greeting = "Hello";
int len = greeting.length();
int n=len-1;
for(int i=0;i<(len/2);i++){
//Using temp to store the char value at index i so
//you can swap it in later for char value at index n
char temp = greeting[i];
greeting[i] = greeting[n];
greeting[n] = temp;
n = n-1;
}
cout<<greeting<<endl;
}
// A simple C++ program to reverse string using constructor
#include <iostream>
#include <string>
using namespace std;
int main() {
string str = "Hello";
//Use of reverse iterators
string rev = string(str.rbegin(), str.rend());
cout << rev << endl;
return 0;
}
// C++ Program to reverse a string without
// using temp variable
#include <iostream>
using namespace std;
// Function to reverse string and return revesed string
string reversingString(string str, int start, int end)
{
// Iterate loop upto start not equal to end
while (start < end)
{
// XOR for swapping the variable
str[start] ^= str[end];
str[end] ^= str[start];
str[start] ^= str[end];
++start;
--end;
}
return str;
}
int main()
{
string s = "HelloW";
int len = s.length();
cout << reversingString(s, 0, len-1);
return 0;
}
#include <iostream>
using namespace std;
// Recursive function to reverse a given string
// Note string is passed as reference parameter
void reverse(string &str, int k)
{
static int i = 0;
// if we have reached the end of the string
if (k == str.length())
return;
reverse(str, k + 1);
if (i <= k)
swap(str[i++], str[k]);
}
int main()
{
string str = "Hello";
reverse(str, 0);
cout << "Reverse of the given string is : " << str;
return 0;
}
Here is a brute force solution:
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i=0;i<n;++i)
for(int j=0;j<n;++j) if(i!=j) if (nums[i] + nums[j] == target) { vector<int> ret{ i,j };
return ret;
}
}
};
int main()
{
int target = 7;
vector<int> nums{ 1,2,3,4 }; vector<int> ret;
Solution Sol1;
ret = Sol1.twoSum(nums, target);
cout << "Solution is ";
for (auto i = ret.begin(); i != ret.end(); ++i) std::cout << *i << ' ';
}
https://www.youtube.com/watch?v=_8-ht2AKyH4
In computer science, a jagged array, also known as a ragged array, is an array of arrays of which the member arrays can be of different lengths,[1] producing rows of jagged edges when visualized as output. In contrast, two-dimensional arrays are always rectangular[2] so jagged arrays should not be confused with multidimensional arrays, but the former is often used to emulate the latter.
// C program to show the
// implementation of Jagged Arrays
#include <stdio.h>
#include <stdlib.h>
int main()
{
int row0[3] = { 1, 3, 8 };
int row1[2] = { 1, 2 };
int row2[2] = {9,0};
int row3[5] = {10,11,4,20,50};
int row4[1] = {30};
int* jagged[5] = { row0, row1,row2, row3, row4 };
// Array to hold the size of each row
int Size[5] = { 3, 2, 2, 5,1 }, k = 0;
// To display elements of Jagged array
for (int i = 0; i < 5; i++) {
// pointer to hold the address of the row
int* ptr = jagged[i];
for (int j = 0; j < Size[k]; j++) {
printf("%d ", *ptr);
// move the pointer to the
// next element in the row
ptr++;
}
printf("n");
k++;
// move the pointer to the next row
jagged[i]++;
}
return 0;
}
