Distribute Information about Knowledge, Studies, C++ Tutorial, Future Concept, World Most Expensive Things, World Records of highest, longest, largest, tallest and more…
Monday, 31 December 2012
Thursday, 27 December 2012
LAMBORGHINI AVENTADOR 2013
The 2013 Lamborghini Aventador J is one of the latest version of
2013 Lamborghini. A 2013 Lamborghini Aventador J Speedster has made its
official preview at 2012 Geneva Motor Show. The 2013 Lamborghini
Aventador J could be yours, provided you have $2.71 million.
Lamborghini j Aventador |
Wednesday, 26 December 2012
Gold Bar ATM Machine
This
gold vending machine was located at the Abu Dhabi’s Emirates Palace
hotel. This ATM machine dispenses 10-gram 24K bars of solid gold instead
of cash. You can buy a 2.5, 5 or 10 gram gold bar for $193, $343 and
$638 respectively.

Tuesday, 25 December 2012
WORLD SPEED RECORD FOR VEHICLES
![]() |
THRUST SSC |
The
World Motor Sport Council homologated the new world land speed records
set by the team ThrustSSC of Richard Noble, driver Andy Green, on 15
October 1997 at Black Rock Desert, Nevada (USA). This is the first time
in history that a land vehicle has exceeded the speed of sound. The new
records are as follows:
Speed mile 1227.986 km/h (763.035 mph)
Speed kilometre 1223.657 km/h (760.343 mph)
Speed kilometre 1223.657 km/h (760.343 mph)
Engine Two Rolls-Royce Spey turbofan
Initially Rolls-Royce Spey 202
Finally Rolls-Royce Spey 205
Length 16.5 m (54 ft)
Width 3.7 m (12 ft)
Curb weight 10.5 tonnes
Initially Rolls-Royce Spey 202
Finally Rolls-Royce Spey 205
Length 16.5 m (54 ft)
Width 3.7 m (12 ft)
Curb weight 10.5 tonnes
AIR SPEED RECORD AIRCARFT
![]() |
X-15 A |
The
X-15 was based on a concept study from Walter Dornberger for the NACA
for a hypersonic research aircraft.[4] The requests for proposal were
published on 30 December 1954 for the airframe and on 4 February 1955
for the rocket engine. The X-15 was built by two manufacturers: North
American Aviation was contracted for the airframe in November 1955, and
Reaction Motors was contracted for building the engines in 1956.
The X-15A reached a maximum speed of 7,274 km/hr (4,520 m.p.h., 2,021 m/sec) in October 1967, flown by William "Pete" Knight of the U.S. Air Force.
The X-15A reached a maximum speed of 7,274 km/hr (4,520 m.p.h., 2,021 m/sec) in October 1967, flown by William "Pete" Knight of the U.S. Air Force.
Engine XLR-99
Length 15.45 m (51 ft)
Width 6.8 m (22 ft)
Height 4.12 m (14 ft)
Height 4.12 m (14 ft)
Loaded weight 15,420 kg
Empty weight 6,620 kg
Empty weight 6,620 kg
WORLD SPEED RECORD FOR RAILED VEHICLES
![]() |
JR-Maglev |
JR-Maglev,
or SCMaglev (Super-conducting Maglev) is a magnetic levitation train
system developed by the Central Japan Railway Company and Railway
Technical Research Institute (association of Japan Railways Group).The
JR-Maglev system uses an Electro-dynamic Suspension (EDS) system. The
maglev-trains have superconducting magnetic coils, and the guide ways
contain levitation coils. As the train moves, its moving magnetic fields
create a current in the levitation coils because of the magnetic field
induction effect. These currents create a magnetic field that interacts
with the magnetic field of the superconductive coils to create a force
that holds up and stabilises the train. On 2 December 2003, a three-car
train reached a maximum speed of 581 km/h (361 mph) (world speed record
for railed vehicles) in a manned vehicle run.:
Speed 581 km/h (361 mph)
Engine Linear Synchronous Motor (LSM)
WORLD RAIL SPEED RECORD
![]() |
SNCF TGV |
Speed 574.8 km/h (357.2 mph)
Engine Asynchronous Motors TOP TEN EXPENSIVE CARS IN THE WORLD
11. SSC Ultimate Aero
![]() | ||||||
257 mph (413 km/h), 0-60 in 2.7 secs. Twin-Turbo V8 Engine with 1183 hp, base price is $654,400 |
10. Ferrari Enzo
![]() |
217 mph (349 km/h), 0-60 in 3.4 secs. F140 Aluminum V12 Engine with 660 hp, base price is $670,000 |
9. McLaren F1
![]() |
240 mph (386 km/h), 0-60 in 3.2 secs. BMW S70/2 60 Degree V12 Engine with 627 hp, base price is $970,000 |
8. Hennessey Venom GT
![]() |
260 mph (418 km/h), 0-60 mph in 2.5 seconds, has a 6.2-liter LS9 Turbocharged V8 Twin Turbo V8 Engine producing 1200 hp, with a price tag of $950,000 |
7. Zenvo ST1
![]() |
233 mph (374 km/h), 0-60 in 2.9 secs. Twin-Charged 7.0 liter V8 Engine forging 1,104 hp. Base price: $1,225,000 |
6. Maybach Landaulet
![]() |
155 mph (250 km/h), 0-60 mph in 5.2 secs. 6.0-liter V12 Engine, housing 620 hp. Base price is $1,380,000 |
5b. Koenigsegg Agera R
![]() |
260 mph (418 km/h), 0-60 mph in 2.9 secs. 5.0-liter V8 Engine with twin turbo’s, housing 1099 hp. Base price is $1,600,000 |
5a. Lamborghini Reventon
![]() |
211 mph (340 km/h), 0-100 mph in 3.4 secs. 6.5-liter V12 Engine, housing 650 hp. Base price is $1,454,400 |
4. Pagani Zonda Clinque Roadster
![]() |
217 mph (349 km/h), 0-60 in 3.4 secs. Twin turbocharged AMG V12 engine that produces 678 hp. Base price is $1,850,000 |
3. Aston Martin One77
![]() |
220 mph (354 km/h), 0-60 in 3.4 secs. 7.3 litre V12 Engine with 750 hp. Base price: $1,850,000 |
2. Bugatti Veyron
![]() |
267 mph (429 km/h), 0-60 in 2.4 secs. Aluminum, Narrow Angle 8 Liter W16 Engine with 1200 hp, base price is $2,400,000 |
1. Lamborghini Veneno
![]() |
221 mph (356 km/h), 0-60 in 2.8 secs. 6.5 liter, V12 engine with 750 hp, base price is $3,900,000 |
YouTube : WORLD's TOP TEN EXPENSIVE CARS
30 CREATIVE CONCEPT CAR DESIGNS
Check out these 30 creative concept car designs
Watch it on YouTube : 30 CREATIVE CONCEPT CARS
Concept cars are awesome to look at, not only because they often present unique design ideas, but also because they often influence the future design of mainstream automobiles. While you may not find an exact copy of a concept car on the road, the principles that were demonstrated in concept cars 5-10 years ago are now prevalent in automotive design.
Concept cars are awesome to look at, not only because they often present unique design ideas, but also because they often influence the future design of mainstream automobiles. While you may not find an exact copy of a concept car on the road, the principles that were demonstrated in concept cars 5-10 years ago are now prevalent in automotive design.
Mercedes Benz SLS Concept by Husseindesign
Citroen Survolt
Holden Efijy Concept Car
Suzuki Kizashi Concept
Enes GP Concept
Toyota FT-HS Concept Sport Car
Futuristic Enigma Concept Car
Citroën Revolte
2005 Mitsuoka Orochi Concept Car
Volkswagen Terrafine
RCA Vehicle Design 2008
Blue Will
GT Citroen by Laurant Nivalle
Porsche 918 Spyder

Iomega concept
Bugatti Galibier
Opel Siderium
Aston Martin Agora
Audi Shark
The Vortex project
Maserati GranTurismo MC Concept
Citroën Lacoste
Lamborghini Insecta Concept
Lotus Elan
Citroen Metropolis
e-Wolf E2
BMW 2015 Concept
Audi RSQ
BMW CSX Concept by RS-Design
Watch it on YouTube : 30 CREATIVE CONCEPT CARS
Array in C Tutorial
An array is a collection of similar elements. These similar elements could be all ints, or all floats, or all chars, etc. Usually, the array of characters is called a ‘string’, whereas an array of ints or floats is called simply an array. Remember that all elements of any given array must be of the same type. i.e. we cannot have an array of 10 numbers, of which 5 are ints and 5 are floats.
Program Using Array
Let us try to write a program to find average marks obtained by a class of 30 students in a test.
Program Using Array
Let us try to write a program to find average marks obtained by a class of 30 students in a test.
main ( ) { int avg, sum = 0 ; int i ; int marks[30] ; /* array declaration */ for ( i = 0 ; i <= 29 ; i++ ) { printf ( "\nEnter marks " ) ; scanf ( "%d", &marks[i] ) ; /* store data in array */ } for ( i = 0 ; i <= 29 ; i++ ) { sum = sum + marks[i] ; /* read data from an array*/ } avg = sum / 30 ; printf ( "\nAverage marks = %d", avg ) ; } |
Thursday, 20 December 2012
Conditional Operators tutorial
The conditional operators ? and : are sometimes called ternary operators since they take three arguments. In fact, they form a kind of foreshortened if-then-else. Their general form is,
expression 1 ? expression 2 : expression 3 |
What this expression says is: “if expression 1 is true (that is, if its value is non-zero), then the value returned will be expression 2, otherwise the value returned will be expression 3”. Let us understand this with the help of a few examples:
int x, y ; scanf ( "%d", &x ) ; y = ( x > 5 ? 3 : 4 ) ; |
This statement will store 3 in y if x is greater than 5, otherwise it will store 4 in y. The equivalent if statement will be,
if ( x > 5 ) y = 3 ; else y = 4 ; |
Nested IF-ELSE Condition in C tutorial
It is perfectly all right if we write an entire if-else construct within either the body of the if statement or the body of an else statement. This is called ‘nesting’of ifs. This is shown in the following program.
/* A quick demo of nested if-else */ main( ) { int i ; printf ( "Enter either 1 or 2 " ) ; scanf ( "%d", &i ) ; if ( i == 1 ) printf ( "You would go to heaven !" ) ; else { if ( i == 2 ) printf("Hell was created with you in mind"); else printf("How about mother earth !"); } } |
IF-ELSE Condition in C tutorial
The if statement by itself will execute a single statement, or a group of statements, when the expression following if evaluates to true. It does nothing when the expression evaluates to false. Can we execute one group of statements if the expression evaluates to true and another group of statements if the expression evaluates to false? Of course.
i.e.
If his basic salary is less than Rs. 1500, then HRA = 10% of basic salary and DA = 90% of basic salary. If his salary is either equal to or above Rs. 1500, then HRA = Rs. 500 and DA = 98% of basic salary. If the employee's salary is input through the keyboard write a program to find his gross salary.
i.e.
If his basic salary is less than Rs. 1500, then HRA = 10% of basic salary and DA = 90% of basic salary. If his salary is either equal to or above Rs. 1500, then HRA = Rs. 500 and DA = 98% of basic salary. If the employee's salary is input through the keyboard write a program to find his gross salary.
/* Calculation of gross salary */ main( ) { float bs, gs, da, hra ; printf ( "Enter basic salary " ) ; scanf ( "%f", &bs ) ; if ( bs < 1500 ) { hra = bs * 10 / 100 ; da = bs * 90 / 100 ; } else { hra = 500 ; da = bs * 98 / 100 ; } gs = bs + hra + da ; printf ( "gross salary = Rs. %f", gs ) ; } |
IF Condition in C tutorial
The keyword if tells the compiler that what follows is a decision control instruction. The condition following the keyword if is always enclosed within a pair of parentheses. If the condition, whatever it is, is true, then the statement is executed. If the condition is not true then the statement is not executed; instead the program skips past it
The relational operators should be familiar to you except for the equality operator == and the inequality operator !=. Note that = is used for assignment, whereas, == is used for comparison of two quantities. Here is a simple program, which demonstrates the use of if and the relational operators.
if ( this condition is true ) execute this statement ; |
The relational operators should be familiar to you except for the equality operator == and the inequality operator !=. Note that = is used for assignment, whereas, == is used for comparison of two quantities. Here is a simple program, which demonstrates the use of if and the relational operators.
/* i.e. */ main( ) { int num ; printf ( "Enter a number less than 10 " ) ; scanf ( "%d", &num ) ; if ( num <= 10 ) printf ( "What an obedient servant you are !" ) ; } |
Wednesday, 19 December 2012
What are pointers? tutorial
Pointers are aptly named: they "point" to locations in memory. Think of a row of safety deposit boxes of various sizes at a local bank. Each safety deposit box will have a number associated with it so that the teller can quickly look it up. These numbers are like the memory addresses of variables. A pointer in the world of safety deposit boxes would simply be anything that stored the number of another safety deposit box. Perhaps you have a rich uncle who stored valuables in his safety deposit box, but decided to put the real location in another, smaller, safety deposit box that only stored a card with the number of the large box with the real jewelry. The safety deposit box with the card would be storing the location of another box; it would be equivalent to a pointer. In the computer, pointers are just variables that store memory addresses, usually the addresses of other variables.
The cool thing is that once you can talk about the address of a variable, you'll then be able to go to that address and retrieve the data stored in it. If you happen to have a huge piece of data that you want to pass into a function, it's a lot easier to pass its location to the function than to copy every element of the data! Moreover, if you need more memory for your program, you can request more memory from the system--how do you get "back" that memory? The system tells you where it is located in memory; that is to say, you get a memory address back. And you need pointers to store the memory address.
A note about terms: the word pointer can refer either to a memory address itself, or to a variable that stores a memory address. Usually, the distinction isn't really that important: if you pass a pointer variable into a function, you're passing the value stored in the pointer--the memory address. When I want to talk about a memory address, I'll refer to it as a memory address; when I want a variable that stores a memory address, I'll call it a pointer. When a variable stores the address of another variable, I'll say that it is "pointing to" that variable.
C++ Pointer Syntax
Pointers require a bit of new syntax because when you have a pointer, you need the ability to request both the memory location it stores and the value stored at that memory location. Moreover, since pointers are somewhat special, you need to tell the compiler when you declare your pointer variable that the variable is a pointer, and tell the compiler what type of memory it points to.
The pointer declaration looks like this:
<variable_type> *<name>;
For example, you could declare a pointer that stores the address of an integer with the following syntax
int *points_to_integer;
Notice the use of the *. This is the key to declaring a pointer; if you add it directly before the variable name, it will declare the variable to be a pointer. Minor gotcha: if you declare multiple pointers on the same line, you must precede each of them with an asterisk:
// one pointer, one regular int
int *pointer1, nonpointer1;
// two pointers
int *pointer1, *pointer2;
As I mentioned, there are two ways to use the pointer to access information: it is possible to have it give the actual address to another variable. To do so, simply use the name of the pointer without the *. However, to access the actual memory location, use the *. The technical name for this doing this is dereferencing the pointer; in essence, you're taking the reference to some memory address and following it, to retrieve the actual value. It can be tricky to keep track of when you should add the asterisk. Remember that the pointer's natural use is to store a memory address; so when you use the pointer:
call_to_function_expecting_memory_address(pointer);
then it evaluates to the address. You have to add something extra, the asterisk, in order to retrieve the value stored at the address. You'll probably do that an awful lot. Nevertheless, the pointer itself is supposed to store an address, so when you use the bare pointer, you get that address back.
Pointing to Something: Retrieving an Address
In order to have a pointer actually point to another variable it is necessary to have the memory address of that variable also. To get the memory address of a variable (its location in memory), put the & sign in front of the variable name. This makes it give its address. This is called the address-of operator, because it returns the memory address. Conveniently, both ampersand and address-of start with a; that's a useful way to remember that you use & to get the address of a variable.
For example:
#include <iostream>
using namespace std;
int main()
{
int x; // A normal integer
int *p; // A pointer to an integer
p = &x; // Read it, "assign the address of x to p"
cin>> x; // Put a value in x, we could also use *p here
cin.ignore();
cout<< *p <<"\n"; // Note the use of the * to get the value
cin.get();
}
The cout outputs the value stored in x. Why is that? Well, let's look at the code. The integer is called x. A pointer to an integer is then defined as p. Then it stores the memory location of x in pointer by using the address-of operator (&) to get the address of the variable. Using the ampersand is a bit like looking at the label on the safety deposit box to see its number rather than looking inside the box, to get what it stores. The user then inputs a number that is stored in the variable x; remember, this is the same location that is pointed to by p.
The next line then passes *p into cout. *p performs the "dereferencing" operation on p; it looks at the address stored in p, and goes to that address and returns the value. This is akin to looking inside a safety deposit box only to find the number of (and, presumably, the key to ) another box, which you then open.
The keyword new is used to initialize pointers with memory from free store (a section of memory available to all programs). The syntax looks like the example:
int *ptr = new int;
It initializes ptr to point to a memory address of size int (because variables have different sizes, number of bytes, this is necessary). The memory that is pointed to becomes unavailable to other programs. This means that the careful coder should free this memory at the end of its usage.
The delete operator frees up the memory allocated through new. To do so, the syntax is as in the example.
delete ptr;
After deleting a pointer, it is a good idea to reset it to point to 0. When 0 is assigned to a pointer, the pointer becomes a null pointer, in other words, it points to nothing. By doing this, when you do something foolish with the pointer (it happens a lot, even with experienced programmers), you find out immediately instead of later, when you have done considerable damage.
The cool thing is that once you can talk about the address of a variable, you'll then be able to go to that address and retrieve the data stored in it. If you happen to have a huge piece of data that you want to pass into a function, it's a lot easier to pass its location to the function than to copy every element of the data! Moreover, if you need more memory for your program, you can request more memory from the system--how do you get "back" that memory? The system tells you where it is located in memory; that is to say, you get a memory address back. And you need pointers to store the memory address.
A note about terms: the word pointer can refer either to a memory address itself, or to a variable that stores a memory address. Usually, the distinction isn't really that important: if you pass a pointer variable into a function, you're passing the value stored in the pointer--the memory address. When I want to talk about a memory address, I'll refer to it as a memory address; when I want a variable that stores a memory address, I'll call it a pointer. When a variable stores the address of another variable, I'll say that it is "pointing to" that variable.
Pointers require a bit of new syntax because when you have a pointer, you need the ability to request both the memory location it stores and the value stored at that memory location. Moreover, since pointers are somewhat special, you need to tell the compiler when you declare your pointer variable that the variable is a pointer, and tell the compiler what type of memory it points to.
The pointer declaration looks like this:
<variable_type> *<name>;
For example, you could declare a pointer that stores the address of an integer with the following syntax
int *points_to_integer;
Notice the use of the *. This is the key to declaring a pointer; if you add it directly before the variable name, it will declare the variable to be a pointer. Minor gotcha: if you declare multiple pointers on the same line, you must precede each of them with an asterisk:
// one pointer, one regular intint *pointer1, nonpointer1;
// two pointers
int *pointer1, *pointer2;
As I mentioned, there are two ways to use the pointer to access information: it is possible to have it give the actual address to another variable. To do so, simply use the name of the pointer without the *. However, to access the actual memory location, use the *. The technical name for this doing this is dereferencing the pointer; in essence, you're taking the reference to some memory address and following it, to retrieve the actual value. It can be tricky to keep track of when you should add the asterisk. Remember that the pointer's natural use is to store a memory address; so when you use the pointer:
call_to_function_expecting_memory_address(pointer);
then it evaluates to the address. You have to add something extra, the asterisk, in order to retrieve the value stored at the address. You'll probably do that an awful lot. Nevertheless, the pointer itself is supposed to store an address, so when you use the bare pointer, you get that address back.
Pointing to Something: Retrieving an Address
In order to have a pointer actually point to another variable it is necessary to have the memory address of that variable also. To get the memory address of a variable (its location in memory), put the & sign in front of the variable name. This makes it give its address. This is called the address-of operator, because it returns the memory address. Conveniently, both ampersand and address-of start with a; that's a useful way to remember that you use & to get the address of a variable.
For example:
#include <iostream> using namespace std;
int main()
{
int x; // A normal integer
int *p; // A pointer to an integer
p = &x; // Read it, "assign the address of x to p"
cin>> x; // Put a value in x, we could also use *p here
cin.ignore();
cout<< *p <<"\n"; // Note the use of the * to get the value
cin.get();
}
The cout outputs the value stored in x. Why is that? Well, let's look at the code. The integer is called x. A pointer to an integer is then defined as p. Then it stores the memory location of x in pointer by using the address-of operator (&) to get the address of the variable. Using the ampersand is a bit like looking at the label on the safety deposit box to see its number rather than looking inside the box, to get what it stores. The user then inputs a number that is stored in the variable x; remember, this is the same location that is pointed to by p.
The next line then passes *p into cout. *p performs the "dereferencing" operation on p; it looks at the address stored in p, and goes to that address and returns the value. This is akin to looking inside a safety deposit box only to find the number of (and, presumably, the key to ) another box, which you then open.
The keyword new is used to initialize pointers with memory from free store (a section of memory available to all programs). The syntax looks like the example:
int *ptr = new int;
It initializes ptr to point to a memory address of size int (because variables have different sizes, number of bytes, this is necessary). The memory that is pointed to becomes unavailable to other programs. This means that the careful coder should free this memory at the end of its usage.
The delete operator frees up the memory allocated through new. To do so, the syntax is as in the example.
delete ptr;
After deleting a pointer, it is a good idea to reset it to point to 0. When 0 is assigned to a pointer, the pointer becomes a null pointer, in other words, it points to nothing. By doing this, when you do something foolish with the pointer (it happens a lot, even with experienced programmers), you find out immediately instead of later, when you have done considerable damage.
Subscribe to:
Posts (Atom)