ustaad cali

xasa Software Design Using C+

+
An Online Book
Old Version -- No Longer Maintained
Please Refer to the New Version

Simple C++ Programs

Input, Output, and Simple Computations
Output
One of the most basic things that you can do in a program is to write some output to the
screen. In C++ this is usually done with cout as in the following example:

cout << "This is the message that would appear on screen." << endl;
Note that a message string is enclosed in double quotes. The << symbols point in the
direction of data flow: from the message string to the cout output stream. The endl
moves the cursor to the beginning of the next line on the screen. Finally, note that the
command, like all C++ statements, ends with a semicolon.
So, how do you incorporate an output statement like the above into a C++ program? Read
the output.cpp example, which is copied here for convenience:
/* Filename: output.cpp

Author: Br. David Carlson

Date: January 4, 2000

Modified: June 26, 2000

This program merely prints some messages on the screen.

*/

#include <iostream>
using namespace std;

int main(void)
{
cout << "Start of program" << endl;
cout << endl << "You can print whatever you like!" << endl;
cout << endl << "End of program" << endl;

return 0;
}
Items enclosed by /* and */ are comments and are ignored by the compiler. The above
example shows the stype of comments expected at the top of each program. This section
should give the filename, author, date, and a brief (but complete) description. The
description should explain what the program does overall, its inputs, and its outputs.
A short comment that fits on one line can be started with the // symbols. Anything on the
same line but coming after the // is taken as a comment and is ignored by the compiler.
Consider the following two examples:
// This is a comment.
cout << "Hello" << endl; // This is a comment, too.
Let's return to the sample program that we were discussing. The iostream header is
included whenever you want to do input or output. Since most programs use input and
output, you will nearly always want iostream. Note that older C++ compilers have a
similar iostream.h header that can be included. Some compilers support both. In our
examples we will use the version of the header without the .h extension. (Warning:
sometimes the two versions do not give exactly the same capabilities.) When using
headers without the .h extension, also use the std namespace as shown. This namespace
is needed in order to have access to many items that we will use in our programs.
The program above consists of just a main function. All C++ programs must have a main
function. They can also have other functions. program begins at the top of the main
function. There are other ways to write a main function (such as using void, not int, in
front of main, but the above method is about very common and will be used throughout
these notes. The int in front of main indicates that the main function will return an
integer value to the operating system when the function is finished. You can see that the
last line of the main function does indeed return the value 0. (Especially in the UNIX
operating system, this return value can be used to check on how a program finished. For
example, 0 could be used for successful termination and some other number could be
returned to indicate an error condition. We will not really use main's return value in our
examples.)
Execution of the program begins at the top of the main function. Note that the commands
to be carried out by the main function are listed in sequence inside of curly braces. These
commands are carried out in sequence, one after the other, unless they contain something
that alters this standard order of execution. The last command inside of the main function
is typically return 0.

Note that the commands inside of a function (and the braces) are indented a uniform 3
spaces. This is a typical indenting style. Although the compiler does not care about
indenting, it makes it much easier for those people who must read the program. In this
case, it makes it clearer what statements belong to the main function.
See proto.cpp for an outline of a typical C++ program file. It shows how the comment
section should be laid out, where to include the headers, etc.

Compiling and Running a Program

Now that we have a C++ program, what do we do with it? Before we can run it on a
computer, the program has to be compiled (translated into machine code). Then you run
the program itself. Exactly how to do all of this depends very much on what compiler you
are using. Read Using the Compiler, especially the section on Using Microsoft Visual C+
+ 5.0, if this is your compiler. Note that if you already have a C++ source code file (such
as the output.cpp above), you can get a quick start by just double clicking on the
filename in MyComputer and accepting the suggestion of building a default workspace.
If you are creating a new program from scratch it is better to follow the directions in
Using the Compiler.

Input
If we can do output, surely we can also do input. The usual method involves reading data
from the cin input stream. This normally reads its data from what the user types at the
keyboard. For example, to read in an integer (int as it is called), you might use:
int num;
cin >> num;
Note the use of the variable num. A variable is used to hold a value, much like a variable
in algebra. In C++ all variables must be declared. Here the variable num is declared to be
of type int, which means that it can hold a whole number (withing some reasonable
range). A variable is implemented as a named memory location. Thus, the name num
refers to some location in the computer's main memory where the value for num is stored.
Our input statement is one way in which to place a value into the variable num. Note that
the >> symbols point in the direction of data flow: from the cin stream to the variable.

Look at iotest.cpp for an example program that uses both input and output. This program
takes the common approach of printing a prompt before each input operation. That way,
the user of the program is instructed about what to enter at each point. Note the use of
two new data types: char and float. A char variable can hold one single character
(letter, digit, or special symbol such as +). A float holds a real value (which can be a
whole number or number with a decimal point, such as 3.1416). Once again there is a
certain range of legal values for a float, but this range is large enough that we can put
off worrying about it for now.

Assignment Statements
Can we do something other than input and output? One thing we can do is to assign a
value into a variable. The simplest form of the assignment statement is as in the following
example:
int num;
num = 45;
A single = sign is used for assignment. It does not mean "equals" as in algebra. (C++ uses
==, two equals signs, for equals.) The = means assignment. An assignment statement is
always executed from right to left. First, the value on the right hard side is figured out
(here the literal number 45) and is then copied into the variable on the left hand side (here
the variable num). Thus, our example copies 45 into the variable.

The left hand side of an assignment statement needs to be a variable, something that can
be assigned a value. The right hand side can be an expression. An expression is anything
that evaluates to a reasonable value. For example, if we have an integer variable on the
left hand side of the = sign, we could use anything that has an integer value on the right
hand side. Here are some examples using integer variable and values:
int num, answer, temp, value;
num = 45;
answer = num + 1;
temp = num;
value = 2 * num + answer;
As before, we place 45 into num. The second assignment statement first figures out the
value of its right hand side as 46 and then copies the 46 into answer. The next one copies
45 from num into temp. The last one looks up the values of num and temp to figure out its
right hand side value (as 136) and then copies the 136 into value.

Assignment statements can also be used to put character data into character variables. A
literal character value must be written with single quotes around it, as in 'A', whereas a
literal integer or floating point value is written without quotes, as in 3.1416. Here is an
example using some assignment statements with character variables:
char Ch, Save;
Ch = 'T';
Save = Ch;
In this short example, the character T is copied into variable Ch. The second assignment
statement starts on the right hand side, evaluating Ch as 'T'. This character is then copied
into the variable Save.

Simple Computations
Assignment statements can be used to carry out simple computations. At last we can
compute something! For example, to find the area of a rectangle we would want to
multiply the length by the width and probably then store the answer in some variable. The
computation could be carried out by an assignment statement such as:
Area = Length * Width;
Look at area1.cpp for an example program that finds the area of a rectangle. It uses float
variables since the length, width, and area might not be whole numbers. Note how the
user is prompted to enter the length and width. Note, too, how different sections of the
program are separated by blank lines. That is not too important in such a short program,
but in longer ones in can help greatly in improving readability. Consistently indenting by
3 spaces all of the items inside of the function is also used as before.

Back to the main Software Design Page

n maax ×Welcome to Q&A for

professional and enthusiast programmers — check out the FAQ!

Stack Exchange
log in | careers | chat | meta | about | faq
search

Stack Overflow
• Questions

• Tags

• Users

• Badges

• Unanswered

• Ask Question

What does Int Main() mean in C++ ?

up
I have used the code many times as the starting of my program but never knew what it
vote
really meant which brought me to the question,What does Int Main() mean in C++ ?
0 c++
down link|edit|flag
vote favorite

asked Feb 15 '10 at 2:16

H4cKL0rD
352426

73% accept rate

 15

Watch the capitalization... C++ is case sensitive. int main() – Brian R. Bondy Feb 15 '10 at 2:19

Sorry Good Tip +1 – H4cKL0rD Feb 15 '10 at 2:31

6 Answers
active oldest votes
up
The function main is the first function executed in a compiled C/C++ program (unless you jump
vote
through hoops to configure it otherwise). Why is it called main and not do_this_function_first?
12 Probably to keep similarities to earlier programming languages.
down
vote accepted
By convention, your program returns an integer value (the return value of main) to the shell to
indicate whether the program completed successfully (a zero) or non-successfully (non-zero,
often related to an error code).

link|edit|flag
answered Feb 15 '10 at 2:19

Mark Rushakoff
43.9k244107

While it's the primary entry point, global and static initialization can cause other functions to be
called prior to main (i.e. int x = foo(); outside of the function will cause mean foo() will be
executed prior to main()). – R Samuel Klatchko Feb 15 '10 at 2:41

@R Samuel I didn't know that. Interesting, thanks! – Ninefingers Feb 15 '10 at 2:49

@R Samuel: That is true, however, in some operating systems (especially ones that don't have
.init/.fini section support), compilers are basically required to put all the .init code into the top of
main instead (and register .fini code with atexit). Hence, it's very important for main to be
compiled with a C++ compiler (even though main usually has no name mangling done to it,
 unlike most other C++ functions), even if all the other C-like functions used by the program can
instead be compiled with a C compiler. – Chris Jester-Young Feb 15 '10 at 2:53

@ChrisJester-Young - thanks, that's an interesting portability issue to know about. – R Samuel

Klatchko Feb 15 '10 at 3:02

up
The main function is the entry point to your program, meaning that the code there will execute
vote
when your program starts. You are declaring the main function to return an integer. You are
2 supposed to return 0 if your program ran successfully and a non-zero value otherwise.
down link|edit|flag
vote answered Feb 15 '10 at 2:18

Raul Agrait
1,673725

up
From the C++ Primer, 4th edition:
vote

1 "Every C++ program contains one or more functions, one of which must be named main. A
function consists of a sequence of statements that perform the work of the function. The
down
vote operating system executes a program by calling the function named main. That function
executes its constituent statements and returns a value to the operating system. The operating
system uses the value returned by main to determine whether the program succeeded or failed.
A return value of 0 indicates success. The main function is special in various ways, the most
important of which are that the function must exist in every C++ program and it is the (only)
function that the operating system explicitly calls. We define main the same way we define
other functions. A function definition specifies four elements: the return type, the function name,
a (possibly empty) parameter list enclosed in parentheses, and the function body. The main
function may have only a restricted set of parameters.[...] The main function is required to have
a return type of int, which is the type that represents integers. The int type is a built-in type,
which means that the type is defined by the language."

Related to the meaning of int main is the following entry in Bjarne Stroustrup's C++ Style and
Technique FAQ:
 Can I write "void main()"?

which also quotes the ISO C++ standard 3.6.12.

Finally, there have been in the past two other questions on stackoverflow that are very related:

why do we give int main in c++ and not void main?

and

Difference between void main and int main?

link|edit|flag
edited Feb 15 '10 at 3:22

answered Feb 15 '10 at 2:28

Alexandros Gezerlis
1,104210

up
It's the entry point to your program - the primary, "main" function, as it were.
vote

0 link|edit|flag
answered Feb 15 '10 at 2:17
down
vote
Michael Petrotta
18.9k22149

up
Main is the entry point in to you program, for a c or c++ program to run you must have this Main
vote
method as the point for your program to start executing from. It also takes in command line
0 arguments you wish to pass in. more info here:
down http://en.wikipedia.org/wiki/Main_function_%28programming%29#C_and_C.2B.2B
vote
link|edit|flag
answered Feb 15 '10 at 2:19

Craig
38319
 up
I'll add to this, not in "answer" as such but some more technical info. "main" is indeed the
vote
startup routine for most C common runtimes, and C++ and as such Java has static void Main()
0 too, for no other reason than history. What usually happens is the entry point is elsewhere in
down the executable and main is called later after the appropriate libraries are loaded in for the
vote platform.

That said, there are alternatives. Two frequent ones appear on Windows:

WinMain or WMain is the main routine used by the Windows API for GUI applications. You'll see
this, too, with MinGW as well as Visual Studio, using the option from LINK.EXE
/SUBSYSTEM:WINDOWS.

If you were to use /SUBSYSTEM:NATIVE you'd generate a Windows "Native App", that is to
say, Native to the kernel and not to the Win32 subsystem (read up on that if you're
interested - the stuff going on behind the Windows launch screen and programs like chkdisk
are examples on WinNT+ platforms). These processes have an entry point at
NtProcessStartup(), totally different to the main you'd expect.

DLL EntryPoints on Windows are called DllMain, see http://msdn.microsoft.com/en-

us/library/ms682596%28VS.85%29.aspx.

Linux Kernel Module entry points are called init_module.

What I'm trying to say is that main is the standard name for an entry point but not by any means
the only one - many APIs work differently, some with good reason, others not, and not all (in
fact all of the above) don't conform to the usual int main(int argc, char** argv) definition. "main"
in the sense of the the usual option plus all of the above is simply "where your code starts", or if
you want to talk at a system level, the address at which to start executing.

Hope that gives you some background info in case you see any alternatives.

link|edit|flag
answered Feb 15 '10 at 2:47

Ninefingers
8,0541629

Your Answer
•
 •

• http://stackoverflow.com/editing-help

Name
log o Email
never show n

r
in
Home Page
Post Your Answ er

Not the answer you're looking for? Browse other questions tagged c++ or
ask your own question.
Hello World!
This is a collaboratively edited question and answer site for professional and enthusiast
programmers. It's 100% free, no registration required.

about » faq »

tagged
c++ × 58347

asked
1 year ago
viewed
847 times
latest activity
1 year ago
electronics.stackexchange.com
Is the Microblaze soft cpu better than the Cortex M3 soft cpu
– kurtnelle
3 answers fpga

Linked
Difference between void main and int main?
why do we give int main in c++ and not void main?

Related
What does template <unsigned int N> mean?
What does this C++ error mean?
What does this mean const int*& var?
what does this code mean?
what does (int) mean in C programming
What does this C++ code mean?
What does “int 0x80” mean in assembly code?
“int -> int -> int” What does this mean in F# ?
What does this “label” mean in C++?
What does int argc, char *argv[] mean?
What does ~ mean in C++?
what does allocator mean in STL
What does the :: mean in C++?
What does this line mean?
What does string::npos mean
what does this mean ?
What does -> mean in C++?
What does |= mean in C++?
What does int & mean
what does this mean in c int a:16; ?
What does : :: mean in C++?
What does an extra 0 in front of an int value mean?
int max = ~0; What does it mean?
What does this symbol mean in C++? “~”
What does '&' mean in C++?
question feed

about | faq | new blog | chat | data | podcast | legal | advertising info | contact us | feedback always
welcome
■ stackoverflow.com ■ api/apps ■ careers ■ serverfault.com ■ superuser.com ■ meta
■ area 51 ■ webapps ■ gaming ■ ubuntu ■ webmasters ■ cooking ■ game development
■ math ■ photography ■ stats ■ tex ■ english ■ theoretical cs ■ programmers ■ unix
■ apple ■ wordpress
http://creativecommons.org/licenses/by-sa/2.5/
rev 2011.2.17.1
site design / logo © 2011 stack overflow internet services, inc; user contributions licensed under cc-
wiki with attribution required
Stack Overflow works best with JavaScript enabled

Search

Starting out
Getting Started
Tutorials
Lesson 1: The basics
of C++(Printable Version)
Quizzes

Moving on
Advanced Tutorials This tutorial series is designed for everyone: even if
Articles you've never programmed before or if you have
Challenges extensive experience programming in other languages
Tips and Tricks and want to expand into C++! It is for everyone who
Jobs wants the feeling of accomplishment from a working
program.

Tools What do I mean? C++ is a programming language--it

What do I need? will allow you to control your computer, making it do
Compilers what you want it to do. This programming tutorial
Editors series is all about helping you take advantage of C+
Debuggers +.

Resources
Source Code
Syntax Reference
Getting
Snippets
Links Directory
Glossary
Set Up - C++
Book Reviews
Function Lookup Compilers
The very first thing you need to do, before starting
Questions
out in C++, is to make sure that you have a compiler.
Programming FAQ What is a compiler, you ask? A compiler turns the
Message Board
program that you write into an executable that your
Ask an Expert
computer can actually understand and run. If you're
Email
About Us taking a course, you probably have one provided
through your school. If you're starting out on your
own, your best bet is to use Code::Blocks. Our page
on setting up Code::Blocks will take you through
setting up the Code::Blocks compiler in great detail.

Advanced Compiler
Details
If you've got some prior experience, or just want a
menu of choices, you should know that there are
several common compilers. If you're new to
programming, just skip this section!

Some common compilers include Borland C++,

Microsoft C++, and GNU C++.

There are also many front-end environments for the

different compilers--the most common is Dev-C++
around GNU's G++ compiler. Some, such as G++,
are free, while others are not. Please see the compiler
listing for more information on how to get a compiler
and set it up.

Each of these compilers is slightly different. Each one

should support the ANSI/ISO standard C++ functions,
but each compiler will also have nonstandard
functions (these functions are similar to slang spoken
in different parts of a country). Sometimes the use of
nonstandard functions will cause problems when you
attempt to compile source code (the actual C++
written by a programmer and saved as a text file)
with a different compiler. These tutorials use
ANSI/ISO standard C++ and should not suffer from
this problem (with sufficiently modern compilers).
Note that if you are using an older compiler, such as
TCLite, you should read check out some compatibility
issues.

Intro to the C+
+ Language
A C++ program is a collection of commands, which
tell the computer to do "something". This collection of
commands is usually called C++ source code,
source code or just code. Commands are either
"functions" or "keywords". Keywords are a basic
building block of the language, while functions are, in
fact, usually written in terms of simpler functions--
you'll see this in our very first program, below.
(Confused? Think of it a bit like an outline for a book;
the outline might show every chapter in the book;
each chapter might have its own outline, composed of
sections. Each section might have its own outline, or
it might have all of the details written up.) Thankfully,
C++ provides a great many common functions and
keywords that you can use.

But how does a program actually start? Every

program in C++ has one function, always named
main, that is always called when your program first
executes. From main, you can also call other
functions whether they are written by us or, as
mentioned earlier, provided by the compiler.

So how do you get access to those prewritten

functions? To access those standard functions that
comes with the compiler, you include a header with
the #include directive. What this does is effectively
take everything in the header and paste it into your
program. Let's look at a working program:

#include <iostream>

using namespace std;

int main()
{
cout<<"HEY, you, I'm alive! Oh, and Hello
World!\n";
cin.get();
}
Let's look at the elements of the program. The
#include is a "preprocessor" directive that tells the
compiler to put code from the header called iostream
into our program before actually creating the
executable. By including header files, you gain access
to many different functions. For example, the cout
function requires iostream. Following the include is
the statement, "using namespace std;". This line tells
the compiler to use a group of functions that are part
of the standard library (std). By including this line at
the top of a file, you allow the program to use
functions such as cout. The semicolon is part of the
syntax of C++. It tells the compiler that you're at the
end of a command. You will see later that the
semicolon is used to end most commands in C++.

The next important line is int main(). This line tells

the compiler that there is a function named main, and
that the function returns an integer, hence int. The
"curly braces" ({ and }) signal the beginning and end
of functions and other code blocks. You can think of
them as meaning BEGIN and END.

The next line of the program may seem strange. If

you have programmed in another language, you
might expect that print would be the function used to
display text. In C++, however, the cout object is used
to display text (pronounced "C out"). It uses the <<
symbols, known as "insertion operators", to indicate
what to output. cout<< results in a function call with
the ensuing text as an argument to the function. The
quotes tell the compiler that you want to output the
literal string as-is. The '\n' sequence is actually
treated as a single character that stands for a newline
(we'll talk about this later in more detail). It moves
the cursor on your screen to the next line. Again,
notice the semicolon: it is added onto the end of most
lines, such as function calls, in C++.

The next command is cin.get(). This is another

function call: it reads in input and expects the user to
hit the return key. Many compiler environments will
open a new console window, run the program, and
then close the window. This command keeps that
window from closing because the program is not done
yet because it waits for you to hit enter. Including
that line gives you time to see the program run.

Upon reaching the end of main, the closing brace, our

program will return the value of 0 (and integer, hence
why we told main to return an int) to the operating
system. This return value is important as it can be
used to tell the OS whether our program succeeded or
not. A return value of 0 means success and is
returned automatically (but only for main, other
functions require you to manually return a value), but
if we wanted to return something else, such as 1, we
would have to do it with a return statement:

#include <iostream>

using namespace std;

int main()
{
cout<<"HEY, you, I'm alive! Oh, and Hello
World!\n";
cin.get();

return 1;
}
The final brace closes off the function. You should try
compiling this program and running it. You can cut
and paste the code into a file, save it as a .cpp file.
Our Code::Blocks tutorial actually takes you through
creating a simple program, so check it out if you're
confused.

If you are not using Code::Blocks, you should read

the compiler instructions for information on how to
compile.
Once you've got your first program running, why
don't you try playing around with the cout function to
get used to writing C++?

An Aside on
Commenting
Your Programs
As you are learning to program, you should also start
to learn how to explain your programs (for yourself, if
no one else). You do this by adding comments to
code; I'll use them frequently to help explain code
examples.

When you tell the compiler a section of text is a

comment, it will ignore it when running the code,
allowing you to use any text you want to describe the
real code. To create a comment use either //, which
tells the compiler that the rest of the line is a
comment, or /* and then */ to block off everything
between as a comment. Certain compiler
environments will change the color of a commented
area, but some will not. Be certain not to accidentally
comment out code (that is, to tell the compiler part of
your code is a comment) you need for the program.
When you are learning to program, it is useful to be
able to comment out sections of code in order to see
how the output is affected.

User interaction
and Saving
Information
with Variables
So far you've learned how to write a simple program
to display information typed in by you, the
programmer, and how to describe your program with
comments. That's great, but what about interacting
with your user? Fortunately, it is also possible for
your program to accept input. The function you use is
known as cin, and is followed by the insertion
operator >>.

Of course, before you try to receive input, you must

have a place to store that input. In programming,
input and data are stored in variables. There are
several different types of variables which store
different kinds of information (e.g. numbers versus
letters); when you tell the compiler you are declaring
a variable, you must include the data type along with
the name of the variable. Several basic types include
char, int, and float.

A variable of type char stores a single character,

variables of type int store integers (numbers without
decimal places), and variables of type float store
numbers with decimal places. Each of these variable
types - char, int, and float - is each a keyword that
you use when you declare a variable.

What's with all these

variable types?
Sometimes it can be confusing to have multiple
variable types when it seems like some variable types
are redundant (why have integer numbers when you
have floats?). Using the right variable type can be
important for making your code readable and for
efficiency--some variables require more memory than
others. Moreover, because of the way the numbers
are actually stored in memory, a float is "inexact",
and should not be used when you need to store an
"exact" integer value.

Declaring Variables
in C++
To declare a variable you use the syntax "type
<name>;". Here are some variable declaration
examples:

int x;
char letter;
float the_float;
It is permissible to declare multiple variables of the
same type on the same line; each one should be
separated by a comma.
int a, b, c, d;
If you were watching closely, you might have seen
that declaration of a variable is always followed by a
semicolon (note that this is the same procedure used
when you call a function).

Common Errors when

Declaring Variables in
C++
If you attempt to use a variable that you have not
declared, your program will not be compiled or run,
and you will receive an error message informing you
that you have made a mistake. Usually, this is called
an undeclared variable.

Case Sensitivity
Now is a good time to talk about an important
concept that can easily throw you off: case sensitivity.
Basically, in C++, whether you use uppercase or
lowercase letters matters. The words Cat and cat
mean different things to the compiler. In C++, all
language keywords, all functions and all variables are
case sensitive. A difference in case between your
variable declaration and the use of the variable is one
reason you might get an undeclared variable error.

Using Variables
Ok, so you now know how to tell the compiler about
variables, but what about using them?

Here is a sample program demonstrating the use of a

variable:

#include <iostream>

using namespace std;

int main()
{
int thisisanumber;

cout<<"Please enter a number: ";

cin>> thisisanumber;
cin.ignore();
cout<<"You entered: "<< thisisanumber
<<"\n";
cin.get();
}
Let's break apart this program and examine it line by
line. The keyword int declares thisisanumber to be an
integer. The function cin>> reads a value into
thisisanumber; the user must press enter before the
number is read by the program. cin.ignore() is
another function that reads and discards a character.
Remember that when you type input into a program,
it takes the enter key too. We don't need this, so we
throw it away. Keep in mind that the variable was
declared an integer; if the user attempts to type in a
decimal number, it will be truncated (that is, the
decimal component of the number will be ignored).
Try typing in a sequence of characters or a decimal
number when you run the example program; the
response will vary from input to input, but in no case
is it particularly pretty. Notice that when printing out
a variable quotation marks are not used. Were there
quotation marks, the output would be "You Entered:
thisisanumber." The lack of quotation marks informs
the compiler that there is a variable, and therefore
that the program should check the value of the
variable in order to replace the variable name with
the variable when executing the output function. Do
not be confused by the inclusion of two separate
insertion operators on one line. Including multiple
insertion operators on one line is perfectly acceptable
and all of the output will go to the same place. In
fact, you must separate string literals (strings
enclosed in quotation marks) and variables by giving
each its own insertion operators (<<). Trying to put
two variables together with only one << will give you
an error message, do not try it. Do not forget to end
functions and declarations with a semicolon. If you
forget the semicolon, the compiler will give you an
error message when you attempt to compile the
program.

Changing and
Comparing Variables
Of course, no matter what type you use, variables are
uninteresting without the ability to modify them.
Several operators used with variables include the
following: *, -, +, /, =, ==, >, <. The * multiplies,
the - subtracts, and the + adds. It is of course
important to realize that to modify the value of a
variable inside the program it is rather important to
use the equal sign. In some languages, the equal sign
compares the value of the left and right values, but in
C++ == is used for that task. The equal sign is still
extremely useful. It sets the left input to the equal
sign, which must be one, and only one, variable equal
to the value on the right side of the equal sign. The
operators that perform mathematical functions should
be used on the right side of an equal sign in order to
assign the result to a variable on the left side.

Here are a few examples:

a = 4 * 6; // (Note use of comments and of

semicolon) a is 24
a = a + 5; // a equals the original value of
a with five added to it
a == 5 // Does NOT assign five to a.
Rather, it checks to see if a equals 5.
The other form of equal, ==, is not a way to assign a
value to a variable. Rather, it checks to see if the
variables are equal. It is useful in other areas of C++;
for example, you will often use == in such
constructions as conditional statements and loops.
You can probably guess how < and > function. They
are greater than and less than operators.

For example:

a < 5 // Checks to see if a is less than

five
a > 5 // Checks to see if a is greater than
five
a == 5 // Checks to see if a equals five, for
good measure
Comparing variables isn't really useful until you have
some way of using the results--that's what lesson 2,
on if statements is all about.

Did you follow that? Quiz yourself

Next: If Statements - Conditionally Changing Program
Behavior
Back to the tutorial index
If you're having some trouble following the tutorial,
try some expert help.

Want something in hard copy? Try

Join our mailing list to keep up with the latest news

and updates about Cprogramming.com!

Name

Email

Join Mailing List

 -----

Interested in advertising with us?

Please read our privacy policy.
Copyright © 1997-2005 Cprogramming.com. All
rights reserved.

C++ : Documentation : C++ Language Tutorial : Arrays

Search
Search:

login: sign in

[register]
remember me

C++

Information

Documentation

Reference

Articles

Sourcecode

Forums

Documentation

C++ Language Tutorial

Ascii Codes

Boolean Operations

Numerical Bases

C++ Language Tutorial

Introduction:

· Instructions for use

Basics of C++:

· Structure of a program

· Variables. Data Types.

· Constants

· Operators

· Basic Input/Output

Control Structures:

· Control Structures

· Functions (I)

· Functions (II)

Compound Data Types:

· Arrays

· Character Sequences

· Pointers

· Dynamic Memory

· Data Structures

· Other Data Types

Object Oriented
Programming:

· Classes (I)

· Classes (II)

· Friendship and inher...

· Polymorphism

Advanced Concepts:

· Templates

· Namespaces
 · Exceptions

· Type Casting

· Preprocessor directi...

C++ Standard Library:

· Input/Output with fi...

Arrays
Published by Juan Soulie
Last update on Sep 29, 2009 at 10:53am UTC
An array is a series of elements of the same type placed in contiguous memory locations that can be individually referenced by adding an
index to a unique identifier.

That means that, for example, we can store 5 values of type int in an array without having to declare 5 different variables, each one with
int for example, with a unique
a different identifier. Instead of that, using an array we can store 5 different values of the same type,
identifier.

For example, an array to contain 5 integer values of type int called billy could be represented like this:

where each blank panel represents an element of the array, that in this case are integer values of type int. These elements are numbered
from 0 to 4 since in arrays the first index is always 0, independently of its length.
Like a regular variable, an array must be declared before it is used. A typical declaration for an array in C++ is:

type name [elements];

where type is a valid type (like int, float...), name is a valid identifier and the elements field (which is always enclosed in
square brackets[]), specifies how many of these elements the array has to contain.
Therefore, in order to declare an array called billy as the one shown in the above diagram it is as simple as:

int billy [5];

NOTE: The elements field within brackets []

which represents the number of elements the array is going to hold, must be a
constant value, since arrays are blocks of non-dynamic memory whose size must be determined before execution. In order to create arrays
with a variable length dynamic memory is needed, which is explained later in these tutorials.

Initializing arrays.
When declaring a regular array of local scope (within a function, for example), if we do not specify otherwise, its elements will not be
initialized to any value by default, so their content will be undetermined until we store some value in them. The elements of global and static
arrays, on the other hand, are automatically initialized with their default values, which for all fundamental types this means they are filled
with zeros.

In both cases, local and global, when we declare an array, we have the possibility to assign initial values to each one of its elements by
enclosing the values in braces { }. For example:

int billy [5] = { 16, 2, 77, 40, 12071 };

This declaration would have created an array like this:

The amount of values between braces{ } must not be larger than the number of elements that we declare for the array between square
brackets[ ]. For example, in the example of array billy we have declared that it has 5 elements and in the list of initial values within
braces { } we have specified 5 values, one for each element.

When an initialization of values is provided for an array, C++ allows the possibility of leaving the square brackets empty [ ]. In this case,
the compiler will assume a size for the array that matches the number of values included between braces { }:

int billy [] = { 16, 2, 77, 40, 12071 };

After this declaration, array billy would be 5 ints long, since we have provided 5 initialization values.

Accessing the values of an array.

In any point of a program in which an array is visible, we can access the value of any of its elements individually as if it was a normal
variable, thus being able to both read and modify its value. The format is as simple as:

name[index]

Following the previous examples in which billy had 5 elements and each of those elements was of type int, the name which we can
use to refer to each element is the following:

For example, to store the value 75 in the third element of billy, we could write the following statement:

billy[2] = 75;

and, for example, to pass the value of the third element of billy to a variable called a, we could write:

a = billy[2];

Therefore, the expression billy[2] is for all purposes like a variable of type int.
Notice that the third element ofbilly is specified billy[2], since the first one is billy[0], the second one is
billy[1], and therefore, the third one is billy[2]. By this same reason, its last element is billy[4]. Therefore, if we
write billy[5], we would be accessing the sixth element of billy and therefore exceeding the size of the array.

In C++ it is syntactically correct to exceed the valid range of indices for an array. This can create problems, since accessing out-of-range
elements do not cause compilation errors but can cause runtime errors. The reason why this is allowed will be seen further ahead when we
begin to use pointers.

At this point it is important to be able to clearly distinguish between the two uses that brackets [ ] have related to arrays. They perform
two different tasks: one is to specify the size of arrays when they are declared; and the second one is to specify indices for concrete array
elements. Do not confuse these two possible uses of brackets [ ] with arrays.

1 int billy[5]; // declaration of a new array

2 billy[2] = 75; // access to an element of the array.

If you read carefully, you will see that a type specifier always precedes a variable or array declaration, while it never precedes an access.

Some other valid operations with arrays:

1 billy[0] = a;
2 billy[a] = 75;
3 b = billy [a+2];
4 billy[billy[a]] = billy[2] + 5;

1 // arrays example 12206

2 #include <iostream>
3 using namespace std;
4
 5 int billy [] = {16, 2, 77, 40,
6 12071};
7 int n, result=0;
8
9 int main ()
10 {
11 for ( n=0 ; n<5 ; n++ )
12 {
13 result += billy[n];
14 }
15 cout << result;
16 return 0;
}

Multidimensional arrays
Multidimensional arrays can be described as "arrays of arrays". For example, a bidimensional array can be imagined as a bidimensional table
made of elements, all of them of a same uniform data type.

jimmy represents a bidimensional array of 3 per 5 elements of type int. The way to declare this array in C++ would be:

int jimmy [3][5];

and, for example, the way to reference the second element vertically and fourth horizontally in an expression would be:

jimmy[1][3]

(remember that array indices always begin by zero).

Multidimensional arrays are not limited to two indices (i.e., two dimensions). They can contain as many indices as needed. But be careful! The
amount of memory needed for an array rapidly increases with each dimension. For example:

char century [100][365][24][60][60];

declares an array with a char element for each second in a century, that is more than 3 billion chars. So this declaration would consume
more than 3 gigabytes of memory!

Multidimensional arrays are just an abstraction for programmers, since we can obtain the same results with a simple array just by putting a
factor between its indices:

1 int jimmy [3][5]; // is equivalent to

2 int jimmy [15]; // (3 * 5 = 15)
With the only difference that with multidimensional arrays the compiler remembers the depth of each imaginary dimension for us. Take as
example these two pieces of code, with both exactly the same result. One uses a bidimensional array and the other one uses a simple array:

multidimensional array pseudo-multidimensional array

#define WIDTH 5 #define WIDTH 5
#define HEIGHT 3 #define HEIGHT 3

int jimmy [HEIGHT][WIDTH]; int jimmy [HEIGHT * WIDTH];

int n,m; int n,m;

int main () int main ()

{ {
for (n=0;n<HEIGHT;n++) for (n=0;n<HEIGHT;n++)
for (m=0;m<WIDTH;m++) for (m=0;m<WIDTH;m++)
{ {
jimmy[n][m]=(n+1)*(m+1); jimmy[n*WIDTH+m]=(n+1)*(m+1);
} }
return 0; return 0;
} }

None of the two source codes above produce any output on the screen, but both assign values to the memory block called jimmy in the
following way:

We have used "defined constants" ( #define) to simplify possible future modifications of the program. For example, in case that we
decided to enlarge the array to a height of 4 instead of 3 it could be done simply by changing the line:

#define HEIGHT 3
to:
#define HEIGHT 4

with no need to make any other modifications to the program.

Arrays as parameters
At some moment we may need to pass an array to a function as a parameter. In C++ it is not possible to pass a complete block of memory
by value as a parameter to a function, but we are allowed to pass its address. In practice this has almost the same effect and it is a much
faster and more efficient operation.

In order to accept arrays as parameters the only thing that we have to do when declaring the function is to specify in its parameters the
element type of the array, an identifier and a pair of void brackets []. For example, the following function:

void procedure (int arg[])

accepts a parameter of type "array of int" called arg. In order to pass to this function an array declared as:

int myarray [40];

it would be enough to write a call like this:

procedure (myarray);

Here you have a complete example:

 1 // arrays as parameters 5 10 15
2 #include <iostream> 2 4 6 8 10
3 using namespace std;
4
5 void printarray (int arg[], int
6 length) {
7 for (int n=0; n<length; n++)
8 cout << arg[n] << " ";
9 cout << "\n";
10 }
11
12 int main ()
13 {
14 int firstarray[] = {5, 10, 15};
15 int secondarray[] = {2, 4, 6, 8,
16 10};
17 printarray (firstarray,3);
18 printarray (secondarray,5);
return 0;
}

As you can see, the first parameter ( int arg[] ) accepts any array whose elements are of type int
, whatever its length. For that
reason we have included a second parameter that tells the function the length of each array that we pass to it as its first parameter. This
allows the for loop that prints out the array to know the range to iterate in the passed array without going out of range.
In a function declaration it is also possible to include multidimensional arrays. The format for a tridimensional array parameter is:

base_type[][depth][depth]

for example, a function with a multidimensional array as argument could be:

void procedure (int myarray[][3][4])

Notice that the first brackets [] are left blank while the following ones are not. This is so because the compiler must be able to determine
within the function which is the depth of each additional dimension.

Arrays, both simple or multidimensional, passed as function parameters are a quite common source of errors for novice programmers. I
recommend the reading of the chapter about Pointers for a better understanding on how arrays operate.

Previous:Previous: Next:Next:
Previous: Next:
Functions (II) index Character Sequences

Home page | Privacy policy

© cplusplus.com, 2000-2010 - All rights reserved - v2.3
Spotted an error? contact us