Iterations

Some statements in programming and scripting languages are described as being iterative statements. These statements are structured and have conditions and terminating factors to control how many times the code in that block is executed. PHP has four major and commonly used iterative structures that we’ll look at now. These are:

• ‘while’
• ‘do … while’
• ‘for’

While

The while statement is probably the most basic one of the lot. It simply executes a block of code continuously looping until it’s condition is no longer met. However if the condition is never met, the code is never executed.

<?php
while (expression) {
  statements;
  }
?>

or…

<?php
$x = 0;
while ($x < 10) {
  echo 'Variable x holds the value: ' . $x;  // Note the use of the dot character to concatenate the string.
  $x++;
  }
?>

Do…while

With a traditional while statement the code will execute for the duration of time that it’s conditional statement is made true. With a do…while loop however the code will execute once regardless of the conditional and only loop again if it’s conditional statement is met. Always a useful tool if you want something to happen at least once…

<?php
do {
  statements;
  }
while (expression);
?>

or…

<?php
$x = 0;
do {
  echo 'Variable x holds the value: ' . $x;  // Note the use of the dot character to concatenate the string.
  $x++;
} while ($x < 10) ;
?>

For

The for loop lets programmers perform a loop based on an incremental value until it reaches it’s terminating value. Unlike the while loop the variable changes as part of the condition meaning less code in the body of the loop as we no longer need to adjust this variable in the loop to help it reach it’s terminating condition.

<?php
for (initialisation; condition; increment) {
  statements;
 }?>

Summary

So that’s about it really! You should now understand the basics of PHP iterations and loops. All be what this post is about is pretty basic it is important to understand. My next post will be on if/else loops and case/switch statements as these have some special rules that would be a bit much to include in this post I believe. Go forth, young padawans…and iterate :)

or…

<?php
for ($x = 0; $x < 10; $x++;) {   $a = $a + $b[$x];   $x++;   } ><

So that’s

If you imagine that when a program is made, it uses up ‘blocks’ of standard memory simply for it to run (while this is often minute, it’s still important to take into account). Memory is used upon compilation based on the number of instantiated variables within the code (ints, chars etc). This use of memory can be visualised as a grid with each block of memory available/used as squares within this grid. What malloc does is tell the program to ‘set aside’ a given number of blocks of memory for later or current use.

Using malloc

When using malloc, there are two things to take into account. These are:

1. Casting malloc to the variable type you wish to make dynamic.

When calling malloc on a variable, you want to tell it what kind of variable it is. This is done by ‘casting’ malloc.

2. The size of each block of memory you are setting aside.

Different variables hold different sizes of memory. For example, an int has a size of four bytes. Telling malloc how large each block of memory needs to be is very important. If you do not do this, you will have problems trying to get the code to work in the way you wanted.

When using malloc, C is very intelligent when it comes to creating the dynamic arrays. Due to the nature of C89 programming, you must define a size for each array you instantiate within your code. This means that a dynamic array is structured a little differently. This is where pointers come in.

Pointers

A pointer is not a variable that holds a specific value. Instead, it points to a location in memory being held by the type of variable that it is. For example:

int *my_pointer;

This doesn’t allow storage of a value of type ‘int’. Instead, it ‘points’ to the location in memory for an int.

Why use pointers then? Simple; malloc assigns blocks of memory to a variable, but as this variable is going to be of unknown size at the time of compilation, you want the pointer to at least know where the memory is.

Two simple steps to making your own dynamic array

1. Instantiate two variables; One of type int (which will be a storage for the number of elements you want in your array), and the other being a pointer of the type of variable you wish to store within your array.

int bits_of_memory, *my_array;

2. When you have decided on how many elements your array will have, you need to malloc the pointer to point to that number of blocks of memory. Don’t forget to CAST the malloc!

   my_array = (int*)malloc(bits_of_memory * sizeof(int));
   

What is going on here? When you are assigning malloc to your array pointer, note that you have to cast it to the type of variable that it is. In this case, it’s a pointer to an int (i.e. ‘int*’). The number of blocks of memory is then reliant on the value of ‘bits_of_memory’. This is then multiplied by the total size of a single integer (four bytes).

If you imagine that the variable ‘bits_of_memory’ had a value of 4, malloc will set aside “4 ‘times’ the size of the variable” blocks of memory for you:

[int][int][int][int][  ][  ][  ]

And it’s that simple! Yes, it really is. As long as you remember the type of variables you’re playing around with, malloc will allow you to dynamically set aside blocks of memory.

Handling the array

As mentioned before, C is very intelligent when handling dynamic arrays. The moment you use malloc on a pointer, it automatically assumes you want to turn it into an array. This means that you can now use the variable like an array.

my_array[0] is completely legal.

In the example program below, I have placed the reading into and printing of the variable into a for loop. This makes handling the array on a complete scale a lot easier, especially if you want to place all of the information in in one go.

Example program:

/*
 * File:   main.c
 * Author: Josh Greatrex
 *
 * Created on 08 February 2010, 16:08
 *
 * This file should give you a basic working knowledge of how malloc works
 * and how it can be used in C programming. Please feel free to copy this
 * source code and compile it yourself.
 */

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

int main() {

    int bits_of_memory, *my_array, i;

    printf("How big do you want this array to be? ");
    scanf("%d", &bits_of_memory);

    /* Allocates memory for the array */
    my_array = (int*)malloc(bits_of_memory * sizeof(int));

    /* Allows the user to enter the values into the array */
    for(i = 0; i < bits_of_memory; i++) {
        printf("Enter the value for element %d: ", (i+1));
        scanf("%d", &my_array[i]);
    }

    /* Prints off all of the element values from the array */
    for(i = 0; i < bits_of_memory; i++) {
        printf("Value for element %d is %d\n", (i+1), my_array[i]);
    }

    return 0;
}

Each node within the list contains the set data as well as a ‘pointer’ to the next node within the list; hence ‘Linked List’.

Linked Lists in C utilise three things:

1. malloc
2. structs
3. Pointers

Creating the structure

A C struct acts as a ‘node’ within the Linked List. One of the better ways to declare a C struct is to ‘typedef’ it as such:

#include <stdio.h>
#include <stdlib.h>

typedef struct my_struct_name {
    /* Declare the variables you want in each node */
    int i, j;
    char c;
    double d;

    /* Pointer for next node in list */
    struct my_struct_name *next_node;
} my_struct;

Note: The struct has, in essence, two names. Why? Well, the first name ‘my_struct_name’ refers to that ‘type’ of struct. The second name ‘my_struct’ refers to that specific struct. Also note that there is a pointer within the struct, of that type, which will be used to point to the next node within the list.

And that’s the simplest way to create a node. So, what’s next?

When inserting and retrieving information from the linked list, you will not be calling the struct directly. You in fact need to create three more pointers, external to the struct. These are:

my_struct *first_node, *current_node, *last_node

These pointers will be what you refer to when dealing with your list.

Malloc and Struct syntax

Let’s miss out the part regarding file reading for now (that will be covered in another article) and assume you know what values you want within the list. How are you going to insert them? Quite simple:

1. Begin a loop
2. Malloc the current node in order to reserve memory for that node:

current_node = (my_struct*)malloc(sizeof(my_struct));

3. If the head of the list has not been made, assign the current node to be the head of the list (or ‘first_node’). If the head already exists, assign the current_node to be the last_node’s ‘next_node’ pointer:

if(first_node == NULL)
    first_node = current_node;

else
    current_node = last_node -> next_node;

4. Insert your values by representing the variables within the current node in the structure:

/*Remember this is a pointer and represents the structure*/
&current_node -> i = 42;
&current_node -> j = 100;
current_node -> c = 'a';
&current_node -> d = 13.37;

When you insert into the node, you use the ‘current_node’ pointer ALWAYS. When you call ‘current_node’, you’re calling the structure it represents at a specific block of memory (previously reserved by malloc). The ‘->’ means that you wish to insert or retrieve a value from a variable within the structure. It essentially tells the code to ‘look inside’ the struct and find the variable.

Note: When inserting integer, double, float, or long values into a variable, make sure you use the ‘&’ symbol beforehand.

5. Assign last_node to be the node you’ve just inserted to (as you will be moving on to the next node afterwards:

/* This is important as you might be at the end of the list */
current_node -> next_node = NULL;
last_node = current_node;

These steps are relatively simple to follow and they outline the important parts of creating a simple single linked list using malloc and pointers.

Displaying information from a Linked List

This is very simple and only requires you to set the start node and what rules there are to loop through the list. The most basic version is thus:

current_node = first_node;

while(current_node -> next_node != NULL) {
    printf("One of the values in this node is: %d", current_node -> i);

    /* Set the current_node to point to the next node in the list */
    current_node = current_node -> next_node;
}

This loop will begin at the head of the list, and work its way through each node as long as ‘current_node -> next_node’ is not empty (a.k.a the end of the list).

char array[5] = "Test\0";

Note: Every string ends in a ‘Null Terminator’ which is shown by a ‘\0′. If you do not add this at the end of your string, C will actually add one for you. However, this acts as an element within the array so if you don’t add it, make sure that the fixed size is one more than the number of characters (including white spaces).

Outputting the elements of a string in one consecutive line requires ‘%s’ in the output.

printf("My array is: %s", array);

Output:

My array is: Test

When printing the array, there is no need to display particular elements (i.e. array[0]) as the variable ‘array’ itself is a pointer to the initial element within itself. Using %s then goes through the entire array.

White Spaces

When a string contains white space (e.g. spaces within a sentence) the output will not complete the string after the first instance of white space, as it classes it as a terminator. In order to do this, you will need to use regular expressions.

printf("My array is: %[A-Za-z ]", array);

The REGEX within the square brackets tells the program to output any letters from A-Z, a-z, and also white spaces.

In order to create an array of strings, you first need two things. You need the actual array container itself, which is a pointer to a pointer of type ‘char’. You will also need a pointer to a char.

/* This is the array that currently has no set size */
char** string_array;

/* Note that no size has been set yet for this */
char* string;

Now that you have these two chars, you can use malloc() to designate blocks of memory, and add some text for the first string:

string = (char *)malloc(6 * sizeof(char));

/* strcpy() places text into the string */
strcpy(string, "Hello");

Note: When allocating blocks of memory for an array of characters, you will need to know how many characters there are going to be. In this case, I have allocated 6 blocks of memory. This is to hold each letter in the string, and one more for the null terminator (‘\0′);

You then need to allocate memory for the array itself to hold a set number of elements. In this case, it will only be two elements:

*string_array = (char *)malloc(2 * sizeof(char *));

Now you can add the first string to the first element of the array (element 0):

/* Adds value of 'string' to element 0 of 'string_array' */
*string_array = string;

It is possible to then assign a new value to ‘string’, which is good if you are looping as it saves you having to create multiple strings. In this case, we want to assign a new value to ‘string’ and place it into the next element of ‘string_array’:

string = (char *)malloc(6 * sizeof(char));

/* strcpy() places text into the string */
strcpy(string, "World");

*(string_array+1) = string;

Note: I have placed the second string into element ’1′ of ‘string_array’ by placing a ‘+1′ after calling ‘string_array’. If you are using this in a loop, then you can do ‘+i’ or whatever you have named the incrementing variable.

You have now just created a very simple array of Strings in ANSI C! If we print out this code, it will look like this:

printf("%s %s", *(string_array), *(string_array+1));

Output:

Hello World

Whole code:

#include <stdio.h>
#include <stdlib.h>

int main() {
    /* This is the array that currently has no set size */
    char** string_array;

    /* Note that no size has been set yet for this */
    char* string;

    string = (char *)malloc(6 * sizeof(char));

    /* strcpy() places text into the string */
    strcpy(string, "Hello");

    *string_array = (char *)malloc(2 * sizeof(char *));

    /* Adds value of 'string' to element 0 of 'string_array' */
    *string_array = string;

    string = (char *)malloc(6 * sizeof(char));

    /* strcpy() places text into the string */
    strcpy(string, "World");

    *(string_array+1) = string;

    printf("%s %s", *(string_array), *(string_array+1));

    return 0;
}

eXtensible HyperText Markup Laguage (acronym XHTML) is a growing Markup Language (based on the XML markup language itself) that extends that of SGML Markup Language currently well known as HTML (HyperText Markup Language) and defines how web pages are written and presented in Web Browsers. Whereas HTML maybe considered as a very flexible language to use when writing up websites, XHTML is based upon the XML standard whereby standard are more restrictive. This in turn requires pages to be written in a well formed and structured way in order to pass the online validation services offered.

Document Type Declaration

<!DOCTYPE HTML
    PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">       //Note for  XHTML 1.1 DTD
<html xmlns="http://www.w3.org/1999/xhtml">

History

XHTML was developed to be a step in the right direction for the Web by working on a language which would be fully compatible and compliant with Web Browsers and the HTML 4 specification. By using the XML standard (approved in 1998 link) the HTML language would hopefully be more (ideally completely) compatible XML tools, servers and proxies would be able to transform content, as necessary, for constrained devices such as mobile phones as well as other mobile devices.

For any webpage to be written within XHTML (Transitional or Strict) and pass validation, there must be no styling elements within the XHTML page itself. Whereby these styling elements can be written into a separate styling file (such as CSS or XMS files) and referenced from the XHTML page.

XHTML 1.0 became a World Wide Web Consortium (W3C) Recommendation on January 26, 2000. XHTML 1.1 became a W3C Recommendation on May 31, 2001. XHTML5 is undergoing development as of September 2009, as part of the HTML5 specification. link.

Relevent Extensions

.xhtml, .xht, .xml, .html, .htm

This section is for showcasing current and past projects by the users of this website.

URL: http://www.the-undergraduate.co.uk/dev

The include() statement

Essentially, it is like the echo command in that it will output the contents of files to the php page. Text files for example will be displayed on the page. PHP files are also displayed on the page, but it renders to HTML beforehand, and you can’t see the actual code. This is a fact that many PHP developers use on a daily basis. Including a PHP file is effectively the same thing as if the contents of that file had been written into the main PHP file.

For example, if I had a PHP file called echo.php

<?php
      echo("hello there");
?>

and another file called main.php

<?php
      include("echo.php");
?>

Output:

hello there

This, essentially (on a virtual level) pastes the echo statement into the middle of the main.php file. This can be seen as basic Object Oriented scripting within PHP.

What makes this very useful in larger projects is that if you have a website where the content changes very frequently, you could have your main.php file display the header and footer and stuff and include a content.php file in the middle. In which case, instead of having to sift through a potentially large amount of code to find your content, you only have to change the content.php file. This is used for efficiency and for the ability to write thousands of complicated and messy functions in one file and reduce it to a single line include statement in the file where the functions are required.

If an include() statement fails, i.e. if the file does not exist, the include will generate an error of level E_WARNING. I will go through error levels in detail at some other time, but for now it is suffice to say that this will post a warning to your page and continue to execute the PHP script. This can be insecure for larger projects where the scripts may then generate errors from functions not existing, which could result in sensitive data being posted to anybody who visits the page.

The require() statement

It is exactly the same in functionality as the include() statement, but if it fails, it will generate an error of level E_ERROR which is seen by PHP as a fatal run-time error. This will write the error message to the screen, and then halt execution of the script completely. Therefore, it is much more secure.

So why use include() at all? Why not just use require() all the time if it’s so much more secure?

Because, include and require both handle errors in different ways, one or the other is more preferable in different scenarios. For example, when handling sensitive data in secure e-commerce transactions for example, you want the scripts to terminate to prevent things going disastrously wrong so that you don’t end up pulling silly amounts of money out of someone’s bank account or displaying bank details and database passwords etc on the page for the world to see. In this case, you would use require(). You would probably then want the page to catch the error, terminate scripts and redirect to a “safe” page which apologises profusely for the mess-up and promises that the issue will be resolved as soon as possible.

However, for other less critical projects, it is likely that you will want the page to continue displaying content so that the site can function as normally as possible. You’d catch the error (this will be covered in future PHP posts) and display an error message to the user saying “technical difficulties” or whatever and let the site get on with it.

Example:

<div style="background: #CDCDCD; font-weight: bold;">
    Test.
</div>

Outcome:

It is very important to remember that the CSS can only lie within the style=”" element of a tag.

DIV Classes

A DIV class represents a non-unique identifier for the HTML code. What this means is that you may have multiple DIVs on one page with the same class. In essence, they belong to the same ‘family’, and share design traits (omitting dimensions and positions). In CSS, when looking at classes, they are represented with a full stop (‘.’).

.my_class_1 {
    background: #ffffff;
}

.my_class_2 {
    background: #000000;
}

This is a very simple example of how two different classes have different aspects to them. In order to apply these effects to a DIV, you simply need to add the ‘class’ inside the tag:

<div class="my_class_1">
    This is a class test...
</div>

This class can be applied to as many DIV elements on a single page as you want, but if everything looks the same, the page can look ‘bland’. This is where DIV ID tags come in…

DIV IDs

These work in very similar ways to Classes in DIVs, but are limited to one ID per element. This means that you are not allowed to have more than one DIV on a single page with the same ID. The idea behind this is to allow the user to specify different design aspects to different DIV tags without calling more classes than you need to.

In CSS, an ID is represented as a hash (‘#’):

#my_id_1 {
    background: #ffffff;
}

#my_id_2 {
    background: #000000;
}

As you can see, it works in almost an identical way to DIV classes. In HTML, the code to apply an ID to a DIV would be:

<div id="my_id_1">
    This is an ID test...
</div>

So, that’s the basic idea of using Class and ID inside DIV tags in HTML to their full advantage… Separately.

Due to CSS setting aspects of Classes and IDs separately, you are able to set different styles to them. What does this mean? Well, it means that you are in fact able to ‘merge’ these two styles together.

Merging

Imagine that you have a basic web page layout, with say, 4 DIVs. Now we can tell from this that we want 4 different ID styles within the CSS. When it comes to classes, we can have a range from 1 to 4. In this case, we will have only 1. Now, imagine that this is a rather formal web page and everything must conform to a certain set of design rules. We can use the DIV class to set up a ‘standard’ design for each DIV. This will make sure that the general aspect of the DIVs together are the same.

Each ID can then be used to set smaller and individual styles for each DIV. If each DIV is going to represent a different aspect of the web page, they are going to need to be distiguishable from one another. From this idea, we can come up with a simple set of CSS to allow the style to conform to the standard of the web page:

/* CLASSES  */

.div_class {
    background: #CDCDCD;
}

/* IDs */

#id_1 {
    font-weight: bold;
}

#id_2 {
    text-decoration: underline;
}

#id_3 {
    text-align: right;
}

#id_4 {
    text-align: left;
}

With the CSS sorted, you can now apply these styles to the DIVs within the HTML:

<div id="id_1" class="div_class">
     DIV ID = 1.
<div>

<div id="id_2" class="div_class">
     DIV ID = 2.
<div>

<div id="id_3" class="div_class">
     DIV ID = 3.
<div>

<div id="id_4" class="div_class">
     DIV ID = 4.
<div>

The output should look like:

——

——

——