Lately I have been searching  this post on the net about graphics.h in dev c++ and found few resources about it .  So I decided to write how to use graphics.h in dev-c++.  I am expecting that you have already installed bloodshed dev-cpp on your machine.  Graphics.h is a header file found in borlan c but because of its late development devcpp is now the mostly used IDE and compiler in programming c++.

Below are the steps on how to get graphics.h running on your machine,

1. download graphics.h and save it to the include folder where you installed dev-cpp (C:\Dev-Cpp\include)
2. Download libbgi.a and save it in the lib folder where you installed dev-cpp (C:\Dev-Cpp\lib)
3. So when you have to create a program that needs the use of graphics.h  you must instruct the linker to link in certain libraries by going to projects > project options > parameters tab > linker column copy the lines below and paste it on that column.

-lbgi
-lgdi32
-lcomdlg32
-luuid
-loleaut32
-lole32

By then you should be able to use graphics.h. As a sample I created this bubble sort algorithm as an example on how to use graphics.h in c++.

The program will have scattered points on the screen and will form a line as the loop iterates and at the end it will display how many loops are needed to sort the randomly generated numbers.

If you have problems using the functions you can refer to this link.  I hope this helps in solving your problem about dev c++ graphics.h with the bubble sort algorithm.

Line begins with //, indicating that the remainder of the line is a comment. Programmers insert comments to document programs and also help people read and understand them. Comments do not cause the computer to perform any action when the program is run; they are ignored by the C++ compiler and do not cause any machine-language object code to be generated. The comment Text-printing program describes the purpose of the program. A comment beginning with // is called a single-line comment because it terminates at the end of the current line. C++ programmers also may use C’s style in which a comment possibly containing many lines begins with the pair of characters /* and ends with */.

#include <iostream>  // allows program to output data to the screen

This is a preprocessor directive, which is a message to the C++ preprocessor. Lines that begin with # are processed by the preprocessor before the program is compiled. This line notifies the preprocessor to include in the program the contents of the input/output stream header file . This file must be included for any program that outputs data to the screen or inputs data from the keyboard using C++-style stream input/output.

CAUTION: Forgetting to include the header file in a program that inputs data from the keyboard or outputs data to the screen causes the compiler to issue an error message, because the compiler cannot recognize references to the stream components (e.g., cout).

int main()

The parentheses after main indicate that main is a program building block called a function. C++ programs typically consist of one or more functions and classes. Exactly one function in every program must be main. Like our program above, it contains only one function. C++ programs begin executing at function main, even if main is not the first function in the program. The keyword int to the left of main indicates that main “returns” an integer (whole number) value. A keyword is a word in code that is reserved by C++ for a specific use. The left brace, {, must begin the body of every function. A corresponding right brace, }, must end each function’s body.

std::cout << "Hello World!\n"; // display message

This instructs the computer to perform an action namely, to print the string of characters contained between the double quotation marks. A string is sometimes called a character string, a message or a string literal. We refer to characters between double quotation marks simply as strings. White-space characters in strings are not ignored by the compiler. std::cout, the << operator, the string “Hello World++!\n” and the semicolon (;), is called a statement. Every C++ statement must end with a semicolon (also known as the statement terminator). Preprocessor directives (like #include) do not end with a semicolon. Output and input in C++ are accomplished with streams of characters. Thus, when the preceding statement is executed, it sends the stream of characters Welcome to C++!\n to the standard output stream objectstd::cout which is normally “connected” to the screen.
If you have noticed that we placed std:: before cout. This is required when we use names that we’ve brought into the program by the preprocessor directive #include .

The << operator is referred to as the stream insertion operator. When this program executes, the value to the right of the operator, the right operand, is inserted in the output stream. Notice that the operator points in the direction of where the data goes. The characters of the right operand normally print exactly as they appear between the double quotes. Notice, however, that the characters \n are not printed on the screen. The backslash (\) is called an escape character. It indicates that a “special” character is to be output. When a backslash is encountered in a string of characters, the next character is combined with the backslash to form an escape sequence. The escape sequence \n means newline. It causes the cursor (i.e., the current screen-position indicator) to move to the beginning of the next line on the screen.

system("pause");

This allows us to see the output of a function. If we don’t apply system(“pause”); on the function it directly exits the console.

return 0; // indicate that program ended successfully

return 0 is one of several means we will use to exit a function. When the return statement is used at the end of main, as shown here, the value 0 indicates that the program has terminated successfully and the } indicated that the function is ended.

#include // I/O library
using namespace std;
int main()
{
cout << “Hello, world!” << endl;
}

The // symbol is used as a rest-of-line comment symbol. Also, the program text can be placed in any position on the page, with white space between tokens being ignored. White space are characters such as blanks, tabs, and new lines. White space, comments, and indentation of text are all used to create a well-documented, readable program but do not affect program semantics.

#include <iostream> // I/O library

The C++ program is compiled after the preprocessor executes #-designated directives. The preprocessor precedes the compiler translation of the resulting program into machine code. The #include directive found in the example program hello.cpp imports any needed files, usually library definitions. In this case, the I/O library for a typical C++ compiler system is found in the file iostream. The compiler knows where to find this and other system files.

Using namespace std;

On C++ systems, standard C++ I/O header files are wrapped in namespace std. The using declaration allows names to be used without std:: prepended to each name. The include files could have been coded without namespace and using, as follows:

#include <iostream.h> // I/O library

Most systems provide older style library_name.h header files. These libraries do not require the using namespace std; statement.

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main() {
string line;
int count = 0;
ifstream FileName (“try.txt”);
if (FileName.is_open() && !FileName.eof()){
while (getline(FileName,line)){
count++;
}
}
else cout << “Error opening file!” << endl;

cout << “The number of lines in the file is ” << count << endl;

system(“pause”);

}


This program counts the number of lines in a text file. I used the getline function to count it. The getline function is used to create a string containing all of the characters from the input stream until the end of file is found or the delimiter.

Its syntax is getline(char *s, streamsize n) or getline(char *s, streamsize n, char delimiter).

The difference between them is that tche first one includes blank lines in counting while the second one contains a delimiter which can be any character depending on what you want to base your count on (e.g. newline). By replacing the getline function above with this getline(FileName, string, ‘\n’), it will count lines in the text with text and not include the blank lines.