Category of operators

Unary Operators
A unary operator is an operator, which operates on one operand.

Binary
A binary operator is an operator, which operates on two operands

Ternary
A ternary operator is an operator, which operates on three operands.

Following are the different types of Operators

Arithmetic Operator
The arithmetic operator is a binary operator, which requires two operands to perform its operation of arithmetic. Following are the arithmetic operators that are available

At the time of using the ‘/’ division operator on two integers, the result will also be an integer. E.g. 100/8 will result in 12 and not 12.50.

Unary Operators

A unary operator is an operator, which operates on one operand, i.e. it operates on itself.

Following are the unary operators available under C

!  &  *  -  +  ~

Increment and Decrement Operators

These operators also fall under the broad category or unary operators but are quite distinct than unary minus.

The increment and decrement operators are very useful in C language. They are extensively used in for and while loops. The syntax of these operators is given below.

++
++
–
–

The ++ operator increments the value of the variable by one, whereas the – operator decrements the value of the variable by one.

These operators can be used in either the postfix or prefix notation as follows:

Postfix: a++ or a–
Prefix: ++a or –a

Postfix notation

In the postfix notation, the value of the operand is used first and then the operation of increment or decrement takes place, e.g. consider the statements below:

	int a,b;
	a = 10;
	b = a++;
	printf(“%d\n”,a);
	printf(“%d\n”,b);

Program Output
10
11

Prefix notation

In the prefix notation, the operation of increment or decrement takes place first after which the new value of the variable is used.

	int a,b;
	a = 10;
	b = ++a;
	printf(“%d\n”,a);
	printf(“%d\n”,b);

Program Output
11
11

Relational Operators

Relational operators compare between two operands and return in terms of true or false i.e. 1 or 0. In C and many other languages a true value is denoted by the integer 1 and a false value is denoted by the integer 0. Relational operators are used in conjunction with logical operators and conditional & looping statements.

Following are the various relational operators

Closely related to the relational operators is the equality operator as follows:

Example:

Suppose we have three integer variables a, b and c with values 1,2 and 3 respectively.

Logical Operators

A logical operator is used to compare or evaluate logical and relational expressions. There are three logical operators available in the C language.

Truth table for Logical AND

Truth table for Logical OR

Example

Let us take three variables a, b, and c and assume a = 5,b=10 and c=7

a>b && a+b>c

Here a>b will return false hence 0 and a+b>c will return true hence 1. Therefore, looking at the truth table 0 AND 1 will be 0. From this we can understand, that this expression will evaluate to false.

Let us look at the same example using Logical OR (||)

a>b || a+b>c

Here a>b will return false hence 0 and a+b>c will return true hence 1. Therefore, looking at the truth table 0 OR 1 will be 1. From this we can understand, that this expression will evaluate to true.

The Logical NOT operator (!)

The ! (Logical NOT) operator is a unary operator. This operator inverses a logical result.

E.g. if a = 5 and b = 7, then

	!(a == b)

will evaluate to be true. This expression works as follows, a==b evaluates to be false, now because of the ! (NOT) operator, the false is inverted to be true.

Assignment Operator

An assignment operator (=) is used to assign a constant or a value of one variable to another.

Example:

a = 5;
b = a;
interestrate = 10.5
result = (a/b) * 100;

Important Note:

Remember that there is a remarkable difference between the equality operator (==) and the assignment operator (=). The equality operator is used to compare the two operands for equality (same value), whereas the assignment operator is used for the purposes of assignment.

Multiple assignments:

You can use the assignment for multiple assignments as follows:

a = b= c = 10;

At the end of this expression all variables a, b and c will have the value 10. Here the order of evaluation is from right to left. First 10 is assigned to c, hence the value of c now becomes 10. After that, the value of c (which is now 10) is assigned to b, hence the value of b becomes 10. Finally, the value of b (which is now 10) is assigned to a, hence the value of a becomes 10.

Arithmetic Assignment Operators

Arithmetic Assignment operators are a combination of arithmetic and the assignment operator. With this operator, the arithmetic operation happens first and then the result of the operation is assigned.

+=

-=

*=

/=

%=

Conditional Operator

A conditional operator checks for an expression, which returns either a true or a false value. If the condition evaluated is true, it returns the value of the true section of the operator, otherwise it returns the value of the false section of the operator.

Its general structure is as follows:

Expression1 ? expression 2 (True Section): expression3 (False Section)

Example:

a=3,b=5,c;
 
c = (a>b) ? a+b : b-a;

The variable c will have the value 2, because when the expression (a>b) is checked, it is evaluated as false. Now because the evaluation is false, the expression b-a is executed and the result is returned to c using the assignment operator.

Precedence of Operators

Type Conversion

When an operator’s operands are of different data types, C automatically converts them to the same data type. This can affect the results of mathematical expressions. This is called type conversion. In C type conversion can be done by two ways, viz.

Automatic Conversion (Arithmetic Promotion)
When a value is converted to a higher type, it is said to be promoted. Let’s look at the specific rules that govern the evaluation of mathematical expressions.

Rule 1: chars, shorts, unsigned shorts are automatically promoted to int.
Rule 2: When an operator works with two values of different data types, the lower data type is promoted to a higher data type.

Type Casting
Type casting means to convert a higher data type to a lower data type. For the purpose of type casting we require to use the type case operator, which lets you manually promote or demote a value. It is a unary operator which appears as the data type name followed by the operand inside a set of parentheses. E.g.

	val = (int)number;

This was about Operators in C, in the next C Tutorial you will learn about input and output in C.

Subscribe now to receive updates when a new C tutorial is released.

A constant can be defined as “a quantity that does not change during the execution of a program”.

#include <stdio.h>
 
void main(void)
{
        int a = 10;
        printf(“%d”,a);
}

Program Output
10

Here we are declaring a variable a with its initial value 10. 10 here is an integer constant and every time you try to execute this program, the output will always be 10.

Types of Constants

Integer Constant
An integer constant must have atleast one digit and should not have decimal point. It could either be positive or negative.

Real Constant
A real constant must have atleast one digit and must have a decimal point.

Character Constant
A character constant should be only one character and must be enclosed in single quotes e.g. ‘A’, ‘b’, etc.

Variables

A variable is a name give to the space in the memory for holding data such as integers, characters, floating point numbers, strings, etc. Using a variable name is more convenient than using the memory locations.

There are certain rules for naming variables for which you need to refer to the rules for identifiers.

Declaration of variables
To declare a variable means to create a memory space for the variable depending on the data type used and associate the memory location with the variable name. In C all the variables should be declared before it can be used. Also you cannot re-declare a variable once it has been already declared.

The general pattern for declaring a variable is as follows:

, , ;

e.g.:

	int age;
	int age, count, i,j;
	float amount, rateofinterest, totalbalance;
	char ch;

Constant Variables

A constant variable is also called a named constant. A named constant is really a variable whose content is read-only and cannot be changed while the program is running. Here is a declaration of a named constant.

	const float pi = 3.14;

It looks just like a regular variable declaration except that the word const appears before the data type name. const is a qualifier that tells the compiler to make the variable read only. Its value will remain constant throughout the programs execution.

An initialization value must be given when declaring a variable with the const qualifier, or an error will result when the program is compiled. A compiler error will also result if there are any statements in the program that attempt to change the contents of a named constant.

Data type modifiers

We have so far learned about the fundamental data types, why they are used, their default sizes and values. Now let us understand the need for data type modifiers and the way they can be used.

Let us consider an example of a program, which will accept an age from the user to do some processing. Because the age is represented in numbers, so we will have to use the integer data type int. We all know that even under exceptional case an age of a person cannot exceed more than 150. Now, that we are using an integer data type it occupies 2 Bytes of memory, which would not be required to represent the value 150. Instead the value 150 could easily be saved in an integer of 1 Byte in size, but the default size of an integer is 2 Bytes. So we have a problem here.

Well, not that we can’t solve. To override the default nature of a data type, C has provided us with data type modifiers as follows:

signed
By default all data types are declared as signed. Signed means that the data type is capable of storing negative values.

unsigned
To modify a data type’s behavior so that it can only store positive values, we require to use the data type unsigned.

For example, if we were to declare a variable age, we know that an age cannot be represented by negative values and hence, we can modify the default behavior of the int data type as follows:

       unsigned int age;

This declaration allows the age variable to store only positive values. An immediate effect is that the range changes from (-32768 to 32767) to (0 to 65536)

long
Many times in our programs we would want to store values beyond the storage capacity of the basic data types. In such cases we use the data type modifier long. This doubles the storage capacity of the data type being used. E.g. long int annualsalary will make the storage capacity of variable annualsalary to 4 bytes.

The exception to this is long double, which modifies the size of the double data type to 10 bytes. Please note that in some compilers this has no effect.

short
If long data type modifier doubles the size, short on the other hand reduces the size of the data type to half. Please refer to the example of age variable to explain the concept of data type modifiers. The same will be achieved by providing the declaration of age as follows:

	short int age;

This declaration above, will provide the variable age with only 1 byte and its data range will be from -128 to 127.

This was about constants, variables and data type modifiers. In the subsequent C Tutorials you will learn about C Operators.

Subscribe now to receive updates when a new C tutorial is released.

We develop programs to accept an input from the user and then run the input through a series of processes and produce the output on screen or on the printer, etc.

INPUT > PROCESS > OUTPUT

From the user’s point of view, the input supplied is data, which requires to be processed. Depending on the input provided by the user i.e. a number, fractional number, a name or an address, etc., the program must be designed to hold all these inputs. C provides the programmer with four basic or fundamental types of container to hold data, which are as follows:

Following is the explanation of data types:

Character data type (char)

The character data type is only 1 Byte in size. It is used for only storing characters.

Integer Data type (int)

The integer data type is used to store whole numbers only. Fractional numbers are not allowed in an int data type.

Data type to store fractional numbers

float

The float data type is used to store floating point numbers or fractional numbers. This data type is 4 Bytes in size. Floating point numbers can also be expressed in the scientific notation e.g. 1.7e4 represents the number 1.7 x 10⁴.

double

The double data type is also used to store floating point numbers or a fractional numbers. This data type is 8 Bytes in size. This data type can hold a large value.

This was about fundamental data types in c. In the subsequent C Tutorials we will learn how to use these data types by creating variables.

Subscribe now to receive updates when a new c tutorial is released.

Of the three languages, C allows the most precise control of input and output. C is also rather more terse than Fortran or Pascal. This can result in short efficient programs, where the programmer has made wise use of C’s range of powerful operators. It also allows the programmer to produce programs which are impossible to understand.

Programmers who are familiar with the use of pointers (or indirect addressing, to use the correct term) will welcome the ease of use compared with some other languages. Undisciplined use of pointers can lead to errors which are very hard to trace. This course only deals with the simplest applications of pointers.

It is hoped that newcomers will find C a useful and friendly language. Care must be taken in using C. Many of the extra facilities which it offers can lead to extra types of programming error. You will have to learn to deal with these to successfully make the transition to being a C programmer.

The course aims to introduce programmers to the C language. Previous programming experience is assumed, so we can quickly progress to looking at the features of C and their uses. Students with little programming experience will need to do some homework in order to keep up with the lectures.

Structure of a C Program

Example

/*A simple C example program*/
#include <stdio.h>
void main(void)
{
	printf(”Hello World”);
}

The output of the program is shown below. This is what appears on the screen when the program runs.

Hello World

Let’s examine the program line by line. Here’s the first line.

/*A simple C example program*/

Other than the two forward slash marks that begin the line, it looks pretty much like ordinary English. The /* marks the beginning of a comment. The compiler ignores everything from the double slash to the end of the line. That means you can type anything you want on that line and the complier will never complain. To end the comment you must close it with */

Although comments are not required, they are very important to programmers. Real programs are much more complicated than the example above, and comments help explain what’s going on.

The next line looks like this:

#include <stdio.h>

Because this line starts with a #, it is called a preprocessor directive. The preprocessor reads your program before it is complied and only executes those lines beginning with a # symbol. The word inside the angular brackets <> is a header file name, which is required to do the work of Input / Output. The contents of stdio.h are included at the point where the #include statement appears. The preprocessor directives should not end with a semicolon because preprocessors are messages to the compiler.

The next line reads:

void main(void)

This starts the beginning of a function. A function can be thought of as a group of one or more programming statements that collectively has a name. The name of this function is main, and the set of parentheses enclosing the word void indicate that it is a function.

Although most C programs have more than one function, every C program must have a function called main. It is the starting point of the program. If you are reading someone else’s C program and want to find where it starts, just look for the function called main.

The next line is a

     {

This is called the left brace and marks the opening or beginning of a function, in our case main. All statements of the main are enclosed in a set of braces.

After the opening brace you see the following line:

	printf(“Hello World”);

This statement displays the string Hello World on screen. We will discuss more about the printf()later on in this chapter.

The last line is a

	}

This marks the end of the function main. Since main is the only function in the program it also marks the end of our program.

A special mention of the semicolon

A semicolon ; is used to mark the end of a statement in C. This allows the complier to understand that the end of a line has been reached. Usually a common mistake is that programmers omit the semicolon and try to compile the program.

The C Character Set

A character denotes any alphabet, digit or special symbol used to represent information. The C character set can be defined as a set of characters permissible under the C language to represent information. Under C, the upper case letters A-Z, the lower case letters a-z, the digits 0-9 and certain special symbols are all valid characters that can be used as building blocks to construct basic program elements.

Following is a table of character sets that are available under C

Alphabets
A, B, C, ………………… Z
a, b, c, ………………… z

Digits
0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Special Characters or Symbols
+ - * & ^ % $ # @ ! ? > < { } [ ] ( ) | \ / “ ‘ : ; . , _

Indentifiers in C

In a C program every word is either classified as an identifier or a keyword.

Identifiers are used to identify or name various program-elements such as variables, symbolic constants, functions, etc.

Rules for Identifiers

1. An identifier can contain letters or letters in any order except that the first character must begin with a letter.
2. C is case-sensitive, therefore upper-case identifiers are different from lower-case characters. E.g. name is different from NAME.
3. An identifier cannot contain any special character. The only exception is the under score character (_), which can also be taken as the first character of an identifier.
4. An identifier cannot be a keyword.

Example of valid identifiers

name, rate1, rate_2, _myname, NAME

Example of invalid identifiers

1stname, my-name, rate 2

Keywords

Keywords are words, which have special meaning for the C compiler. Keywords cannot be used as identifiers because the programmer would then change the meaning of its implementation. Keywords are also sometimes known as reserved words.

Following is a list of keywords in C

In the next series of tutorials, you will learn Data Types, Constants and Data type modifiers.

Subscribe now to receive updates when a new c tutorial is released.

Steps involved to write a scraping program

1. Visit the URL
2. Understand the pattern
3. Validate the structure of pattern on different URLs
4. Write the program
5. Test the program using various input parameters

Lets visit each of these steps one bit at a time.

1. Visit the URL

For this tutorial, we will extract Yahoo’s “Today’s Top Searches” section towards the end of their home page (http://www.yahoo.com/).

2. Understand the pattern

Before you begin to write a web scraping program, its important to understand the pattern of the data that you wish to extract. View the page source to understand the pattern. Mentioned below.

The string of text that we should parse is given below:

 
<div id="popsearchbd" class="bd">
<ol start=1><li><a href="r/dy/*-http://search.yahoo.com/search?p=Heidi+Klum&cs=bz&fr=fp-buzzmod">Heidi Klum</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Sarah+Larson&cs=bz&fr=fp-buzzmod">Sarah Larson</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Oscar+Videos&cs=bz&fr=fp-buzzmod">Oscar Videos</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Brad+Renfro&cs=bz&fr=fp-buzzmod">Brad Renfro</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Gary+Busey&cs=bz&fr=fp-buzzmod">Gary Busey</a></li></ol><ol start=6><li><a href="r/dy/*-http://search.yahoo.com/search?p=Barack+Obama&cs=bz&fr=fp-buzzmod">Barack Obama</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Razzie+Awards&cs=bz&fr=fp-buzzmod">Razzie Awards</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Raisin+in+the+Sun&cs=bz&fr=fp-buzzmod">Raisin in the Sun</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Stay+Home+Moms&cs=bz&fr=fp-buzzmod">Stay Home Moms</a></li><li><a href="r/dy/*-http://search.yahoo.com/search?p=Net+Neutrality&cs=bz&fr=fp-buzzmod">Net Neutrality</a></li></ol></div>
</div>

The pattern is that each Search Phrase is enclosed within a <li><a></a></li> tag. Therefore, we should parse everything between <a></a> of this text piece to get the text.

3. Validate the structure of pattern on different URLs

If you are writing a script to fetch data that has pagination, you should remember to validate the structure on 3 - 4 pages before you start developing code. The reason behind doing this is that the presentation of the first page could differ in subsequent pages.

4. Write the program

You could use any programming language like Java, C#, PHP, PERL, etc. for this processing. I have used PHP for this example.

 
//change fso() to f sock open (my blog was causing an error)
//change fwt() to f write (my blog was causing an error)
//change fgs() to f gets (my blog was causing an error)
//change fc() to f close (my blog was causing an error)
 
$fp = fso("www.yahoo.com", 80, $errno, $errstr, 30);
if (!$fp) {
    echo "$errstr ($errno)<br />\n";
} else {
	$out = "GET / HTTP/1.1\r\n";
	$out .= "Host: www.yahoo.com\r\n";
	$out .= "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12\r\n";
	$out .= "Connection: Close\r\n\r\n";
 
	$str = "";
 
	fwt($fp, $out);
	while (!feof($fp)) {
		$str .= fgs($fp, 1024);
	}
	fc($fp);
}
 
$pos = strpos($str, "<div id=\"popsearchbd\"");
$pos = $pos + strlen("<div id=\"popsearchbd\"");
 
if($pos == false) {
	echo "No information available";
}
else {
 
	while(1) {
		$pos = strpos($str, "fp-buzzmod\">", $pos);
 
		if($pos === false) {
			break;
		}
 
		$pos = $pos + strlen("fp-buzzmod\">");
		$temppos = $pos;
		$pos = strpos($str, "</a>", $pos);
 
		$datalength = $pos - $temppos;
 
		$data = substr($str, $temppos , $datalength);
		echo $data;
		echo "\n";
	}
 
}

5. Test the program using various input parameters

You should test your program for all the parameters that the web page can take. I have experienced change in layout & data based on the parameters that are passed.

Notes on processing forms and cookies

Some pages use form data and cookies to render data. In such cases you should remember to check the Request and Response headers and identify what is necessary to get the results that you want. If the page requires a cookie value, you should then use the cookie information in your Request Headers. Look at the note below that I use to inspect Request and Response headers.

Tool to inspect Request and Response Headers

I use Live HTTP Headers (a plug in for FireFox) to check for Request and Response Headers. Visit http://livehttpheaders.mozdev.org for more details. To install this plug in visit http://livehttpheaders.mozdev.org/installation.html and click on the ‘download it’ link on the latest release. Please read the release notes before installing a particular version.

Please feel free to use the comments section down to share other tools that you guys use to monitor Request and Response Headers.

Future Maintenance of the program

From a maintenance perspective you should monitor the page frequently and re-validate the HTML structure. The reason for this is because nothing in this world is constant and so is the website. Design changes could result in a change in the HTML code. I recommend scheduling this activity for at least once a month.

This is all that is there in this tutorial. In the next tutorial, I will guide you step-by-step on how to create a program to check for yahoo.com search engine ranking. Use the subscribe form below to keep yourself updated when the tutorial goes live.

Would you like to check out some of my PHP5 Tutorials as well?

We all know that India has been receiving consulting projects because of the talent pool we have and secondly because of economical per hour rates when compared to USA and European countries. But, with time other countries are coping up. Their talent pool and per hour rates are comparable to ours.

Take China for example. To my understanding China is not far behind on grounds of talent pool and per hour rates. We have been slightly over-confident about the fact that such projects will keep coming to India because we are the largest English speaking country (http://en.wikipedia.org/wiki/List_of_countries_by_English-speaking_population). But for how long? How long will China be left behind? One fine day China will come up to our levels. What will be the competitive edge that we will have then?

I think it’s time that we start building software products and market them. Ultimately a product offers more power of earning because you develop once and then implement/install everywhere. We should definitely start to think in this direction and start building capacity both educational and entrepreneurial. After all why can’t we have the next best Operating System or an Office Productivity Suite or a Programming Language IDE, etc. etc.

I think India has a lot of scope as regards “Made in India” Software products. Think about it.

Please feel free to add your comments and replies.

Subscribe to free newsletters:

1. Communicate with your clients frequently

This I believe is the most important habit that you should inculcate. Keeping the client in the loop ensures them that you are on top of things and that you are working on their project. Think about it! what if you were the client and were paying someone to develop something. Wouldn’t you want to hear from your vendor frequently?

Issues, slippages, project statuses should be frequently updated to the client (irrespective if your client asks or not). It’s professional ethics!

2. Document interactions with your client

Following point 1, you will have a lot of interactions with your client. You should record/document these interactions as a habit. These interactions could either be in the form of a chat message, emails or function specification documents. Maintaining a history of such interactions will help you during the closure of the project and mainly towards User Acceptance Testing (UAT).

3. Maintain on-going relations with all parties

Just because a project is over does not mean that you should not maintain relations with your clients. Greeting your client on birthdays, anniversaries, etc makes them feel good. This exercise is good to build rapport with clients. It always keeps you fresh in their minds. So, the next time they have a project; guess who gets called first.

In addition to above, you should also maintain relations with suppliers or other freelancers who you outsource work to. In the long run it helps build trust and gives you a good bargaining power. Think about it.

4. Get yourself a professional identity

So what if you freelance, it doesn’t mean that you should not carry yourself professionally. Create professional looking logos, business cards, stationery and website (very important).

Get a professional copy writer to help you with the content of your website. You should mention the projects that you have done and the skills that you have. Always have a contact form on your website where prospective clients can contact you (and when you do get contacted, reply immediately).

5. Seek testimonials from your clients

Seek testimonials from your clients after closing a project. Get this on email and catalogue it for future reference. Also seek their permission to publish their testimonials on your website. In addition to this, you should consider requesting permission from your clients if its ok to give their contact information for reference checks. Some prospective clients would like to talk to your old clients and gauge the experience they have had with you.

6. Create reusable libraries

Creating reusable libraries makes you more profitable. Think about it! If you have been creating email validators on forms for nearly all projects, it makes more sense to create a reusable library and import that library in your current project and make use of it. This way your effort on the project in the long run is reduced and hence you get paid for something that has already been done.

In addition to this, if you discover a bug and fix it, you can apply a patch immediately to all your projects. Saves your time there too and helps all your clients with the bug fix in one go.

7. Maintain proper accounts

Many freelancers (including me) have failed at this. We fail at this not because we don’t know how to handle finances or accounts, but because we are programmers… we love to write code… not books. Do you agree with me?.

But the hard reality is that at the end of the financial year we need to pay taxes. To pay taxes properly we need a good accounting system. The choice is up to you, either be disciplined and maintain proper accounts from day one or waste a lot of time towards the end of the financial year doing it.

I recommend that you do it as you go along. I recommend that you dedicate a weekend to file your papers/accounts properly.

Please feel free to post your comments or add to this list your experiences and best practices.

Subscribe to my free newsletter for article updates:

Related Posts

• 12 common programming mistakes to avoid
• 5 skills every programmer must learn
• 5 reasons ever developer should freelance
• Ideas on debugging your live website
• 5 Tips on improving Programming Logic
• Why should every programmer upgrade knowledge
• 6 billionaire college dropouts

• What is an exception?
• The use of a try…catch block
• Anatomy of PHP5 Exception class
• Extending the Exception class
• A note on unhanded exceptions

What is an exception?

An exception is a logical/system error that occurs during the normal execution of a script. The exception could either be raised by the system or the program itself it the exception cannot be handled and the caller script/function needs to be informed about the same.

The use of a try…catch block

PHP5 introduces the try…catch block to trap exceptions. Look at the example below.

 
try {
   check();
}
catch(Exception $e) {
   echo "Message : " . $e->getMessage();
   echo "Code : " . $e->getCode();
}
 
function check() {
   if(some error condition) {
      throw new Exception("Error String",Error Code);
   }
}

In the above example, the method check() is called between the try {} block. The try{} block is the area where you will place your code that could raise an exception. Below the try{} block is the catch() {} block. The catch block expects the Exception type of object as a parameter. Within the catch() {} block you will place your logic to either fix the issue or log the error.

In the function check(), we raise an Exception using the ‘throw’ keyword. The statement following ‘throw’ is the syntax of creating a new object of Exception type. The exception class accepts two parameters. The left parameter is a string that is the error message and the right parameter is the integer error code that you wish to assign to that error.

Anatomy of PHP5 Exception class

 
class Exception {
	protected $message;
	protected $code;
	protected $file;
	protected $line;
 
	private $string;
	private $trace;
 
	public function __construct($message = null, $code = 0);
	public function __toString();
 
	final public function getCode();
	final public function getMessage();
	final public function getFile();
	final public function getLine();
	final public function getTrace();
	final public function getTraceAsString();
	final private __clone();
}

In the above example, except for __construct and __toString(), no other method can be overridden as all other methods are ‘final’.

Related Reading:

• PHP5 Tutorial - Creating a PHP5 Constructor __construct()
• PHP5 Tutorial - Defining Attributes of a PHP5 Class
• PHP5 Tutorial OOPS - PHP5 Class Access Specifiers - public, private and protected
• PHP 5 Tutorial - Final Class and Methods
• PHP5 Tutorial - Magic Methods - __toString() method

Extending the Exception class

You can also extend the exception class as follows:

 
class CustomerException extends Exception {
 
  public function __construct($message = null, $code = 0) {
 
    $t_message = "Exception raised in CustomerException ";
    $t_message .= "with message : " . $message;
 
    parent::__construct($t_message, $code);
 
    }
 
}
 
 
function testException() {
 
	throw new CustomerException("CustomerException has been raised",101);
 
}
 
try {
	testException();
}
catch(CustomerException $e) {
	echo "Error Message : " $e->getMessage();
	echo "Error Code : " $e->getCode();
}

Output:

Error Message : CustomerException has been raised
Error Code : 101

Related Reading:
PHP5 Tutorial - Inheritance

A note on unhanded exceptions

All un-handled exceptions are passed up the function stack order till the time either a try…catch block is not made available. If a try…catch block is unavailable it is passed to the PHP core and the program execution stops there.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial - Object Oriented Programming (OOPS)

1. PHP5 Tutorial - Learn to create a PHP5 Class
2. PHP5 Tutorial - Learn to Create a PHP5 Class Object
3. PHP5 Tutorial - Defining Attributes of a PHP5 Class
4. PHP5 Tutorial - Defining Methods of a PHP5 Class
5. PHP5 Tutorial - Creating a PHP5 Constructor __construct()
6. PHP5 Tutorial OOPS - Creating a PHP5 Destructor __destruct()
7. PHP5 Tutorial OOPS - PHP5 Class Access Specifiers - public, private and protected
8. PHP5 Tutorial - $this variable explained
9. PHP5 Tutorial - instanceOf Operator Explained
10. PHP5 Tutorial - Defining Class Constants
11. PHP5 Tutorial - Inheritance
12. PHP5 Tutorials - Abstract Class and Interface
13. PHP5 OOPS Tutorials - Polymorphism
14. PHP 5 Tutorials - Static Data Members and Methods
15. PHP 5 Tutorial - Final Class and Methods
16. PHP5 Tutorial - Magic Methods - __toString() method
17. PHP5 Tutorial - Magic Methods - __get() and __set()
18. PHP5 Tutorial - Magic Methods - __isset() and __unset()
19. PHP5 Tutorial - Magic Methods - __call() method
20. PHP5 Tutorial - Magic Methods - __autoload() method
21. PHP5 Tutorial - Magic Methods - __sleep() and __wakeup()
22. PHP5 Tutorial - Magic Methods - __clone() method

• Meaning of Final Class
• Meaning of Final Method
• When to declare a class as final
• When to declare a method as final

Meaning of Final Class

A final class is a class that cannot be extended. To declare a class as final, you need to prefix the ‘class’ keyword with ‘final’. Example below.

 
final class BaseClass {   
   public function myMethod() {
      echo "BaseClass method called";
   }
}
 
//this will cause Compile error
class DerivedClass extends BaseClass {
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, BaseClass is declared as final and hence cannot be extended (inherited). DerivedClass tries to extend from BaseClass and hence the compiler will throw a compile error.

Meaning of Final Method

A final method is a method that cannot be overridden. To declare a method as final, you need to prefix the function name with the ‘final’ keyword. Example below:

 
class BaseClass {   
   final public function myMethod() {
      echo "BaseClass method called";
   }
}
 
class DerivedClass extends BaseClass {
   //this will cause Compile error
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, DerivedClass extends from BaseClass. BaseClass has the method myMethod() declared as final and this cannot be overridden. In this case the compiler causes a compile error.

When to declare a class as final

You should declare a class as final when you think that you implementation of that class should not change in the derived class. You should do this mainly for Utility classes where you don’t want the behavior/implementation of your class to change.

When to declare a method as final

You should declare a class method as final when you think that the method you develop contains necessary functionality to support your application and any modification or change to the functionality can cause unexpected errors/bugs.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial - Object Oriented Programming (OOPS)

1. PHP5 Tutorial - Learn to create a PHP5 Class
2. PHP5 Tutorial - Learn to Create a PHP5 Class Object
3. PHP5 Tutorial - Defining Attributes of a PHP5 Class
4. PHP5 Tutorial - Defining Methods of a PHP5 Class
5. PHP5 Tutorial - Creating a PHP5 Constructor __construct()
6. PHP5 Tutorial OOPS - Creating a PHP5 Destructor __destruct()
7. PHP5 Tutorial OOPS - PHP5 Class Access Specifiers - public, private and protected
8. PHP5 Tutorial - $this variable explained
9. PHP5 Tutorial - instanceOf Operator Explained
10. PHP5 Tutorial - Defining Class Constants
11. PHP5 Tutorial - Inheritance
12. PHP5 Tutorials - Abstract Class and Interface
13. PHP5 OOPS Tutorials - Polymorphism
14. PHP 5 Tutorials - Static Data Members and Methods
15. PHP5 Tutorial - Magic Methods - __toString() method
16. PHP5 Tutorial - Magic Methods - __get() and __set()
17. PHP5 Tutorial - Magic Methods - __isset() and __unset()
18. PHP5 Tutorial - Magic Methods - __call() method
19. PHP5 Tutorial - Magic Methods - __autoload() method
20. PHP5 Tutorial - Magic Methods - __sleep() and __wakeup()
21. PHP5 Tutorial - Magic Methods - __clone() method

• Meaning of static data members
• Meaning of static methods
• Defining static data members in PHP5
• Defining static methods in PHP5
• Accessing static data members in PHP5
• Accessing static methods in PHP5
• Rules to keep in mind for static methods

Meaning of static data members

A data member that is commonly available to all objects of a class is called a static member. Unlike regular data members, static members share the memory space between all objects of the same class.

Meaning of static methods

A static method is a class method that can be called without creating an instance of a class. Such methods are useful when creating utility classes.

Defining static data members in PHP5

To define a static member in PHP5 you need to prefix the class member name with the keyword ’static’. Look at the example below.

 
class Customer {
 
	private $first_name; // regular member
	static public $instance_count; //static data member
 
}

In the above example $instance_count is declared as a static data member

Defining static methods in PHP5

To define a static data methods in PHP5 you need to prefix the class method name with the keyword ’static’. Look at the example below.

 
class Customer {
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}

In the above example getInstanceCount is declared as a static method

Accessing static data members in PHP5

A static member data can be accessed using the name of the class along with the scope resolution operator (::) i.e. you don’t need to create an instance of that class

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::$instance_count;

Output:
2

In the above example, $instance_count is a static data member. Every time a new object is created the constructor is executed and the $instance_count variable is incremented by one. To echo the value contained in $instance_count variable, we use the :: (scope resolution) operator.

Accessing static method in PHP5

A static method can be accessed using the name of the class along with the scope resolution operator (::) i.e. you don’t need to create an instance of that class. However, you can also access it with an instance variable.

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		return Customer::$instance_count;
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::getInstanceCount(); //this is using the scope resolution operator
echo $c1->getInstanceCount(); //this is using the instance variable

Output:
2
2

Rules to keep in mind for static methods

• A static method can only access static data members
• A static method does not have access to the $this variable

Please feel free to write back for any clarification.

Subscribe to my newsletter:

Related Posts on PHP5 Tutorial - Object Oriented Programming (OOPS)

1. PHP5 Tutorial - Learn to create a PHP5 Class
2. PHP5 Tutorial - Learn to Create a PHP5 Class Object
3. PHP5 Tutorial - Defining Attributes of a PHP5 Class
4. PHP5 Tutorial - Defining Methods of a PHP5 Class
5. PHP5 Tutorial - Creating a PHP5 Constructor __construct()
6. PHP5 Tutorial OOPS - Creating a PHP5 Destructor __destruct()
7. PHP5 Tutorial OOPS - PHP5 Class Access Specifiers - public, private and protected
8. PHP5 Tutorial - $this variable explained
9. PHP5 Tutorial - instanceOf Operator Explained
10. PHP5 Tutorial - Defining Class Constants
11. PHP5 Tutorial - Inheritance
12. PHP5 Tutorials - Abstract Class and Interface
13. PHP5 OOPS Tutorials - Polymorphism
14. PHP5 Tutorial - Magic Methods - __toString() method
15. PHP5 Tutorial - Magic Methods - __get() and __set()
16. PHP5 Tutorial - Magic Methods - __isset() and __unset()
17. PHP5 Tutorial - Magic Methods - __call() method
18. PHP5 Tutorial - Magic Methods - __autoload() method
19. PHP5 Tutorial - Magic Methods - __sleep() and __wakeup()
20. PHP5 Tutorial - Magic Methods - __clone() method