As technology changes, it seems that technology device manufacturers also add improvements to their devices. Ice Cream Sandwich is one such, recently released, technology that looks to be extremely beneficial for device manufacturers.

New Framework

One of the biggest changes to the new operating system is the enhanced and unified framework used in the user interface. The new interface includes all the things that you loved about the previous 3.x interface and ads more elements to it; including the new APIs.
Examples of interfaces include the Samsung TouchWiz and Sony Ericsson’s Timescape user interface. The new framework allows device manufacturers to create better and enhanced interfaces. This will make navigation easier and faster than ever before. It will also allow manufacturers to finally make full use of the hardware they put into their devices.

One of the biggest changes to Ice Cream Sandwich is the new unification of contacts and files. This allows device manufacturers to create better storage and access methods for contact and files (photos, music, office documents and videos). This is especially important when it comes to widgets as they have to pull out information from the phone. By unifying a storage method, manufacturer-specific widgets and applications become more efficient than ever before. The new visual voicemail API also lets you get to your voicemail services faster than ever before. These services can be streamlined by device manufacturers to make their device better than the competition.

New Connections

The Android Beam is a new feature that was released with Ice Cream Sandwich. It allows two Android devices to send information directly to each other via Wi-Fi. You can practically share anything so long as you are within range. For device manufacturers and especially developers, this is one amazing innovation. Manufacturers can use this feature to allow almost anything to be shared including themes, widgets and even customizations. With the new Bluetooth Health Device Profile, doctors can easily connect to wireless hospital sensors and other such devices to keep a better track on their patients. If device manufacturers are able to make full use of this profile, it may just revolutionize the health industry.

Enhanced Application Development

Manufacturers can even set up new security, sharing and notification features that are specific to their devices. Manufacturers can also create custom widgets that enable their mobiles to work more efficiently. The new user interface allows device manufacturers to create widgets faster than ever before. All they have to do is program their customizations and the system will add everything else.

Better Camera Function

One of the biggest changes that come with Ice Cream Sandwich is that of enhanced camera capabilities. Better zoom, exposures, focusing and editing function all work efficiently to maximize the capabilities of the built-in cameras. For device manufacturers, this is a great way to maximize the capabilities of their hardware. Not every camera is able to perform well because of the above features. When an operating system is streamlined, its camera function improves as well. In short, the new Ice Cream Sandwich allows device manufacturers to get the most out of their cameras. It also allows them to build on current capabilities. Furthermore, with enhanced image processing and editing abilities, device manufacturers are finally able to make full use of their CPUs and GPUs. It also lets device manufacturers introduce new technology into their mobiles because of the (now) compatible operating system.

This is actually great news for GPU manufacturers who will now be able to create and integrate more powerful GPUs into mobile phones. Not only will the software be able to make full use of the hardware but manufacturers will also be able to create a more power saving solution. The new face detection technology also enables device manufacturers to come up with new ways of improving facial recognition; ways only available on their device. All the changes made in the input services are huge steps and benefits for device manufacturers. They can now finally create pressure and axis based input methods that will allow devices to perform better and more than they ever could. It seems that the new operating system from Android, Ice Cream Sandwich, is proving to be highly beneficial for device manufacturers. The biggest benefit to manufacturers is that they are finally able to make full use of their current and future hardware.

This article is composed and edited by Shannen Doherty. She is a technical content writer. She is associated with many technology and designing communities including Broadband Expert as their freelance writer and adviser. In her free time she writes articles related to: internet, high speed internet providers, technology mobile broadband, etc.

This is a guest post. Mila Johnson is an internet entrepreneur who uses GoDaddy discount codes to save money on her domains. 

Server uptime is one of those “real-world” expectations that is often misunderstood by webmasters and web designers when selecting the right host for their professional web creations. The term uptime is interchangeable with reliability, and it is an important statistic that web hosting providers carefully monitor. Hosting providers that have servers with record uptimes often instruct their marketing and sales personnel to tout those long-running statistics to prospective clients. For techies involved in managing server farms, a lengthy server uptime record is like a badge of honor.

What Uptime Really Means

Uptime can be defined as the uninterrupted time elapsed since any machine or device began operating. Any interruptions in a machine’s operation, including reboots, qualify as downtime. Information technology (IT) professionals may obsess over uptime, but several devices outside of IT have posted impressive uptime records. The ATS-3 satellite, launched by NASA in 1967, was continuously operational until 2001. That’s 34 uptime years. Home refrigerators are known to run for years without being turned off, save for power outages, and nuclear plants have similarly amazing uptimes.

Server computers are regularly subject to downtime caused by issues such as operating system (OS) upgrades, patches, power outages, disaster prevention measures, etc. For these and other reasons, servers that post long-running uptime statistics never fail to impress IT professionals.

Record Uptime Statistics

In 2006, IT industry giant asked its clients to send the company proof of their Netware server uptimes. One client submitted a screen capture of a server running on a 486 that was last rebooted in 2000. The client apologized for not having implemented a patch that fixed a memory leak which required an annual reboot, otherwise the server uptime would have been closer to 9 years.

Uptime statistics are reported by the OS, but this measurement has proven unreliable at least once. In 2009, a Linux server user detected a bug which returned uptime results of nearly 40 years for some Linux OS versions. Still, many Linux servers running on different hardware platforms have reported uptimes of 2000 days.

Apple’s Mac OS X may not be an industry favorite when it comes to server machines, but a website that compiles Mac OS X uptime stats has been tracking a server in Sweden with an uptime longer than 8 years.

Uptime versus Availability

Sever uptime statistics can give webmasters looking for a new place to park their websites a pretty good idea about the host’s level of commitment to its clients. Uptime records can also reveal patterns of administration employed by hosting providers to maintain their servers.

When evaluating different hosting providers, webmasters will invariably hear about 99 percent or higher uptimes. This figure sounds reasonable until actual time is taken into account. A downtime measurement of 9 percent means that a server was not operational for about 87 hours in a year. Assuming that a webmaster needs to see his or her sites up and running around the clock, 365 days a year, those 87 hours could means a lot of lost business.

Availability, the capacity of a server to handle all requests, is a more accurate representation of the dependability webmasters should look for. Besides availability and uptime. what other factors are vital when looking for the ideal web hosting provider?

This is a guest post, thank you Mariana !

Mariana Ashley is a freelance writer who particularly enjoys writing about online colleges. She loves receiving reader feedback, which can be directed to mariana.ashley031 @gmail.com.

No less than a month ago, Microsoft unveiled Windows 8 at the BUILD conference for developers. Described as a “reimagined” operating system (OS) which combines touch interface with traditional mouse and keyboard input, Windows 8 is designed to work across a broad range of devices, most notably the tablet slate (but also any combination of yet-to-be touch-screen laptops, desktop monitors, and possibly phones?).

Metro Development

One of the most notable changes to Windows 8 is the new Metro interface, which looks like a graduated, beefier version of Windows Phone 7. There has been much approval and even some praise over the Metro interface, which runs “Metro style” apps that are developed from a variety of languages:

• C#, C++, or Visual Basic
  • XAML (user interface design)
• Javascript
  • HTML5 and CSS3 (user interface design)

.Net Development

 As for developers trying to figure out how (and whether or not) to code for Windows 8, you are left with a few options. For those with loads of Silverlight experience and .NET Framework know-how, do not worry too much as versions of Windows 8 on x86 processors will run .NET Framework in the “desktop app” which you can access from Metro; so essentially, keep developing for Windows 7, and your programs will be fine on x86 versions of Windows 8. And of course developers who took the patience to understand Windows Presentation Foundation (WPF) will have an easy time creating native Metro apps in XAML.

Where to Start?

With the large variety of programming language options at your disposal, I would begin wherever your strengths direct you. First of course, you will want to download the Windows Developer Preview of Windows 8. As for which device you want to develop Windows 8 “Metro style” apps on, obviously a touch-screen device would be ideal to take advantage of the touch interface. A keyboard dock would also be nice to have, considering you will have a good deal of typing to do. However, there are also many reports of Windows 8 running surprisingly smooth and intuitively on a standard laptop.

From here, I would just stick to Microsoft’s own guide to app-building for Windows 8. It covers every detail, from the basic questions of “what language do I want to build Metro apps in” to planning apps, developing apps, and even outlining different ways to monetize apps. And of course, Microsoft provides some sample apps when you install Windows 8, so you can always base your preliminary coding and interface around the samples, and then later tweak interface and design to fit your apps’ needs.

What is the Strategy design pattern ?

In the formal sense, the Strategy pattern is one that defines a family of algorithms, encapsulated each one of them and makes it so that they can be interchanged. In a more informal and more understandable definition, it’s a neat way to dynamically assign behaviour to a particular client object (class object). Let’s think of an example. Illustrate that we are creating a new game where there is a user that has a first class attribute, which can either be a Ranger, a Fighter, or a Magician. Each class has different skills and, say, different cost to research.

Now, this already creates some questions for us to solve. How will we handle the situation ? Let’s see how one could do it :

1. We could start by having a User class. This class has an attribute named first_class that can be either set as one of the three types (Ranger, Fighter, Magician). Thus, we would see this :

user = User.new
user.first_class = 'Ranger'
puts user.cost

Now, you may already see the problem in this. The cost function implemented by the User class has serious design flaws. Let’s see its possible implementation :

def cost
  if self.first_class == 'Ranger'
    100
  elsif self.first_class == 'Fighter'
    200
  elsif self.first_class == 'Magician'
    130
  end
end

An important design principle of good code is the OPEN/CLOSED principle. That code must be open for extension, but closed for modification. Think what will happen if we ever need to add a new first_class, say ‘Knight’. We would need to change the cost function and every other function that operates in the same IF-ELSE way. That would be a big nightmare and a big design problem. Moreover, user.cost does not actually mean anything. Even if we create the method so that it’s something like user.first_class_cost, we are actually passing first class behavior to the User class. Not a good thing, this class is probably doing too much in terms of responsibilities. We should really make sure that every class only does as much as needed and nothing more. So, how can we make this code better and more extensible ?

Enter The Strategy Design Pattern 

Let’s start by seeing how this code changes when transformed to utilize the Strategy Pattern :

class User
  attr_accessor :name, :first_class

  def first_class= klass
    @first_class = klass.new
  end

  def first_class_description
    @first_class_description = @first_class.description
  end

end

class FirstClass

  def vehicle
    'car'
  end

end

class Ranger < FirstClass

  def cost
    30
  end

end

class Fighter < FirstClass

  def cost
    20
  end

end

See the difference now ? The idea is that we still have a User model, but now we act smarter on defining its first_class. Instead of making it a nightmare String based value, we are actually making it a new model. A new User object now expects a new first_class object in order to operate correctly (we can add it to the constructor as well, if needed). Now, in this example, every first_class gets a new vehicle automatically, so that each new first class character gets a ‘car’. Of course, this can be extended as well, using the same pattern, but it just serves as an example in showing how static things can just stay in the main class. Now, a Ranger, Fighter or anything else, inherits FirstClass and defines a new set of algorithms that operate on the base class. Pretty straight forward i guess.

The best thing about this pattern now is that our object does not need to know what it is, in order to present the description or the cost of its class. The behavior is dynamically set. Let’s see the example execution :

user = User.new

user.first_class = Ranger
puts user.first_class.description
puts user.first_class.cost

user.first_class = Fighter
puts user.first_class_description
puts user.first_class.cost

And when we execute the program we get :

A Ranger here
30
A Fighter here
20

As a side note, see that i also define a first_class_description method, which delegates responsibility directly to the first_class model. This is actually what Rails does with the delegate_to method. It’s a good practice and a fully encapsulated way to do things. That’s it with the Strategy Pattern in Ruby, hope that it will help you in designing your implementation.

Some time ago, i’ve written a post about the basics of git, how to create a local repository on git and more. However, git is a bit complicated, especially if you are switching from subversion. It’s highly likely that you have been using subversion in a remote repository, that is in another machine, and you have been committing your changes there. This is definitely the most standard model that programmers tend to work with.

Although this can happen with git, doing it can be a bit weird. For starters, you need to know that git has 2 different types of repositories. The first one is the non bare repository and the other one is the bare repository. But, what are the differences ?

Git Bare Repository vs Git Non Bare Repository

The bare repository is the one that you are used to with subversion. That is, a repository that has an internal way of representing data, using indexes and more.  On the other hand, a non bare repository actually refers to a working copy of the repository. A copy that just has the files of your project and not any configuration, indexes or other that the non-bare repository has.

5 Easy Steps For Creating Your Remote Repository

1) First, we will create an empty bare repository. The placeholder for our new project. SSH to your server, and give the commands :

mkdir /home/you/git/repository.git

cd /home/you/git/repository.git

git init --bare

This creates your empty bare repository and initializes it as empty.

2) Go the source directory, the one that has your project files. If it’s not in your remote server, just scp it there, upload it via ftp, whatever is more comfortable for you. Let’s say that your root project folder lies on /home/you/project. Now, we need to go to this folder and make it a non-bare repository. We do this with the commands :

cd /home/you/project

git init

3) Now that you have your non-bare repository, you need to add the files to that repository and commit the changes :

git add .

git commit -m 'initial commit'

4. You are now ready to add the bare repository as the remote origin :

git remote add origin /home/you/git/repository.git

5. You are now ready to push the changes to your bare repository, which is now the origin. One command to go :

git push --all

Check out (or clone for git) from your local machine

Your remote repository is ready now. What is left is testing it. Open up a shell in your local computer and execute :

git clone ssh://remote_ip/path_to_project.git new_project

new_project is the name of the folder that will be created with your files inside.

Knowing and executing good HTML is child’s play; knowing and executing good CSS is an art form. I remember the first website I ever built, just a silly teenage “look at me” type of site. It was hosted on Angelfire.com. I used their template at first; then I started making slight customizations until I gradually learned the basic HTML language. By the end of that site’s life, it was filled to the brim with chaotic html code and strange tags to try to achieve awkward sidebar menus and the like.

Later, once I learned CSS, I became extremely drawn to the beauty and simplicity of the code. No longer were my webpages cluttered and clunky with hundreds of lines of code. The beauty of CSS lies in the separation of HTML from web formatting and styling. See, HTML was not initially indented to contain tags for formatting a web page. The tags, such as < h1 > or < p > were initially intended to simply define content. Once HTML 3.2 hit, font tags and color attributes were added. Suddenly, formatting a site with a large amount of pages became a huge, laborious task as web design standards increased.

CSS saves the pain of inputting the same style tags across every page in a site just to make it look uniform because CSS defines how HTML elements are to be displayed and one CSS stylesheet can apply to multiple pages. Meaning, you can define a < h2 > to look larger or smaller (or a different font or color) than the standard tag style. With CSS you can style pretty much any HTML element to your liking. This is how whole navigation menus (even dropdown menus) can be made purely through CSS styling unordered lists < ul > and list items < li >.

CSS Basics

There are two important selectors in CSS, “id” and “class.” The id selector can specify a style for a single and unique element. This means that each element can only have one id and each page can only have one element with that id. So say I only want one < p > to be the color blue. In the CSS stylesheet, I would input:

#bluegraph {
    color: blue;
}

And in the HTML body, I would input:

<p id='bluegraph'>This paragraph is styled blue by its id</p>

And only that paragraph on the page could use that id.

Classes are different from ids in that they are not unique. You can use the same class on multiple elements, and you can also apply multiple classes on the same element. So if I want multiple elements, say a < p > and a < h1 > to share the same blue color style, I would create the class using a similar declaration to id (although classes are declared through “.” and not “#”):

.blue {
  color: blue;
}

And in the HTML body, I would input:

<h1 class="blue">This is a blue heading</h1>
<p class="blue">This is a blue paragraph</p>

And both elements would be blue.

Using Div

Now that we know how to style class and id selectors, we can start to style separate elements of our page differentiated by < div > tags. Most people refer to div tags as containers. So, for a page, you would have a div for your header, your navigation menu, your footer, your main content area, and perhaps a sidebar or two if you’re really fancy. If you have two div elements that are nearly identical, you can use the same class selector to style them. However, I find that most of my div tags are styled with unique id selectors.

The code is actually pretty short, so i think that i will first paste it here and then discuss how it works :

from xml.dom.minidom import Document
from xml.sax.saxutils import unescape

class XmlWriter:

  def __init__(self):
    self.doc = Document()

  def createNode(self, nodeName, parentNode = '', withAttribs = {}):
    node = self.doc.createElement(nodeName)
    if parentNode == '':   # create a parent node
      createdNode = self.doc.appendChild(node)
    else:                  # create a child node
      createdNode = parentNode.appendChild(node)

    if withAttribs != {}:
      for key, value in withAttribs.items():
        self.setAttribute(createdNode, key, value)

    return createdNode

  def setAttribute(self, node, key, value):
    node.setAttribute(key, value)

  def printXML(self):
    print self.doc.toprettyxml(indent="  ")

As you can see, i’m creating an XMLWriter class, that is responsible for creating xml files. I will be using the nice xml minidom package, which is a very nice and simple way to parse and write xml files. With this xml writer, the process of creating an xml file will be even more elegant and the used code will better illustrate what is happening.

In the class contructor (__init__), we create an instance variable named doc. In this one, we execute Document(), to create a Document object and start populating it with nodes and attributes. Our first interesting function is createNode. This one retrieves a node name and has 2 more optional arguments. The first is parentNode and the second one is withAttribs, that actually expects a python dictionary.

A node in XML can either have a parent and be a child, or be a parent node on its own. If we specify a parentNode, then our newly created node will have to be a child of that node. You can see in the actual code of the function that if parentNode is not specified, we create a new node on the document object. Thus, it’s a parent node. If parentNode is specified, though, we create a node that is a child of that one.

A node can also have certain attributes, like <node attrib1 = ”/>. The withAttribs parameters is a way to specify if you want to add attributes to a node or not. If you do not specify a new dict, the newly created node will not have any attributes. If you do, then you just have to pass a dictionary with keys, values that represent the node attributes. The createNode method utilizes setAttribute, which is the actual function responsible for creating attributes for an XML node. You can make this one private if you like, but i prefer to have the ability to execute it as a standalone method as well.

Finally, there is the printXML method that just outputs the resulting XML. Let’s now take a look at an execution example of the class :

doc = XmlWriter()
node = doc.createNode('node1', withAttribs = {'1': 'first', '2': 'second'})
node2 = doc.createNode('node2', node, withAttribs = {'3': 'third'})
node3 = doc.createNode('node3', node, withAttribs = {'4': 'fourth'})
doc.printXML()

You see that we create a parent node with attribs 1= ‘first’ and 2=’second’. Then, we create a child node of the parent node and we name it node2. This one has attrib 3 = ‘third’. Finally, we create another child to the parent node, with attribs 4 = ‘fourth’. Upon execution of the above, we get this output :

<?xml version="1.0" ?>
<node1 1="first" 2="second">
  <node2 3="third"/>
  <node3 4="fourth"/>
</node1>

Of course, you can redirect that to a file like “python XmlWriter.py > example.xml” or just write a class method that will create the file for you. Hope this makes your xml python creation a bit easier now. In a future post i will also create an xml reader class in Python.

This is a guest post

Today i will talk more deeply about Stacks in C++. In the previous tutorial we just declared some methods of this class, so now let’s see their content and in future tutorials we will use Stacks in an application in C++. Let’s start with a look at the template of the class Stack one more time.

template< class T >
class Stack
{
    private:
        Node< T> *top;
        void destroyStack();
        const Stack< T>& reverse();
    public:
        Stack();
        Stack(const Stack< T>& s);
        virtual ~Stack();
        void push(const T &elem);
        void pop(T &x);
        const T& top() const;
        bool empty() const;
        int lenght() const;
        const Stack< T>& operator = (const Stack< T> &s);
        void write(ostream & ostr) const;
};

Now let’s see the content. First the constructors and the default constructor:

template < class T> Stack< T>::Stack() { top = NULL; }

Let’s now check the copy constructor. As we can see, it’s far more complex than the default constructor, but if you pay attention closely, its not much difficult to understand. What we see is just the copy from the content of the stack passed by reference in the “argument bar”, to another stack.

template < class T> Stack< T>::Stack(const Stack< T> &s)
{
    Node< T> * apnode = new Node< T>;
    if(s.top)
        top=apnode;
    else
        top=NULL;
    Node< T> *ap = s.top;
    while (ap != NULL) {
        apnode->info=ap->info;
        if(ap->next == NULL)
            apnode->next=NULL;
        else {
            apnode->next=new Node< T>;
            apnode=apnode->next;
        }
        ap=ap->next;
     }
}

Now, for the destructors. This one is not the typical destructor we normally see and you now why? Because this is not the “true” destructor”. This method is called by the real destructor (below). This one is just a safety method to ensure the clearance of the Stack, element by element in the top of the Stack.

template < class T>
void Stack< T>::destroyStack() {
    Node< T> * temp; while (top)
    {
        temp=top->next;
        delete top;
        top=temp;
    }
}

The real destructor (the one who calls the method above):

template < class T> Stack< T>::~Stack() { destroyStack(); }

The empty method returns a bool(True or False), which means that it tells us if a selected stack is empty or not.

 template< class T> bool Stack::empty() const { return (top==NULL); }

This one is easy to judge by its name; it returns the length of a stack. It’s very useful when we use a for structure or other data structures.

template< class T>
    int Stack< T>::lenght() const
    {
        Node< T> *temp;
        int leng=0;
        temp=top;
        while (temp) {
            leng++;
            temp=temp->next;
        }
        return leng;
     }

Another easy and short implementation. It gives us the element in the top of the stack, which is the only possibility. As you remember, in Stacks, we just have access at the top element.

 template< class T> const T& Stack< T>::top() const { return top->info; }

A method to pop out the element in the top of the stack. Of course, it just pops out if the stack isn’t empty. That’s what the if((empty()) is for.

template< class T>
    void Stack::pop(T & x)
    {
        if (!empty()) {
            x=top->info;
            Node< T>* temp;
            temp=top;
            top=top->next;
            delete temp ;
         }
     }

Push is the opposite of the Pop operation. It is there to insert an element in a stack and will stay in the top of the stack. Last in First Out (LIFO), remember?

template< class T>
    void Stack< T>::push(const T &elem)
    {
        Node< T>* apnode= new Node< T>;
        apnode->info=elem;
        apnode->next=top;
        top=apnode;
    }

Sometimes, it is useful to reverse the content of a stack. The element on the top should be in the bottom and the one in the bottom should be at the top, for easy access. That’s why we need this method, to reverse the stack. The stack is “destroyed/cleared” and through an auxiliary stack with the same content, we pass the elements to the empty stack (the one who was cleared). Since it’s a LIFO, the element on the top will now be on the bottom.

template< class T>
    const Stack< T>& Stack< T>::reverse()
    {
        Stack< T> aux(*this) ;
        T x ;
        destroyStack();
        while (!aux.empty()) {
            aux.pop(x) ;
            push(x) ;
        }
        return *this ;
     }

The attribution method is the one responsible to turn a stack to another one. Pay attention to the “aux.reverse()” line. It’s very important to ensure the elements will not be reversed. Remember again, it’s a LIFO structure. So, to make a “copy” stack we need to reverse the one that will be copied .

template < class T>
    const Stack< T>& Stack< T>::operator = (const Stack< T> & s) {
        Stack< T> aux(s) ;
        T item ;
        destroyStack();
        aux.reverse();
        while (!aux.empty()) {
            aux.pop(item) ;
            push(item) ;
        }
        return *this;
     }

Nothing special here. We do the writing to an ostream and write to it later.

template< class T>
    void Stack::write(ostream & ostr) const {
        Node< T>* temp=top;
        while (temp) {
            ostr << temp->info << " " ; temp=temp->next;
        }
    }

“Hey, this one is not in the class definition!” You’re right, but it’s not necessary. It calls the method above (write) to write the content, so that in the main class we just need to do this: <<”name_of_the_class’s_instance”. It’s another very important practice in C++ called “Operator Overloading”.

template< class T>
    ostream & operator << (ostream & ostr, const Stack< T> & s) {
        s.write(ostr);
        return ostr;
}

That’s all for today. Hope you like it. Next time we can maybe apply this class in a C++ Application.

Base Class and Derived Class

The generic class is termed as base class and the class which inherits from a base class is known as derived class. Normally, a derived class can access all the methods and attributes of the base class. If required, using some keywords, the derived class can be restricted from accessing the attributes of the base class. The keywords used to control the access are public, protected and private. If an attribute or method is declared as public, it can be accessed by the derived class as well as outside functions. That is, if it is part of an instance of the same class. If it is declared as protected, it can be accessed by any derived classes only. If the private keyword is used, the access is completely restricted by all other classes including any derived classes. A : (full colon) is used to indicate that a derived class is inheriting from a base class. The constructor and destructor of the base class cannot be inherited by a derived class.

Multiple Inheritance

It is also possible for a class to inherit from more than one class simultaneously. This is known as multiple inheritance. For example, suppose there are three classes : electronic products, educational products and computer. Here, a computer can inherit both from electronic products class and educational products class.

Now we will consider an example to know in detail of all the concepts explained above.

class Polygon
{
    protected int width, height;
    public void setParameters (int w,int h)
    {
        width = w;
        height = h;
    }
};

class Rectangle : public Polygon
{
    public int calculateArea ()
    {
        return (width*height);
    }
};

class Triangle : public Polygon
{
    public int calculateArea ()
    {
        return( (width*height)/2);
    }
};

int main ()
{
    Rectangle rect;
    Triangle trgl;
    rect. setParameters (4,5);
    trgl. setParameters (4,5);
    cout << rect. calculateArea () << endl;
    cout << trgl. calculateArea () << endl;
    return 0;
}

The statements “Class Rectangle : public Polygon” and “class Triangle : public Polygon” indicate that classes Rectangle and Triangle inherit from the class Polygon. Polygon is the base class and Rectangle, Triangle are derived classes. In the above example, the attributes width and height are declared as protected inside the base class, as their access is intended to be within the derived class alone. Those attributes cannot be accessed within the main function directly. The method calculateArea() is defined differently in both the classes, Rectangle and Triangle.

Advantages of inheritance

The main advantage of inheritance is re-usability. We don’t have to again and again create classes with similar attributes and functions. Once a base class is created and compiled, it is ready to reuse. Even if there are some new features to be added we can inherit it from the existing class and add the required methods or attributes. This consequently saves time and effort for the programmer.

This is a guest post

This tutorial is a simple explanation of some data structures that we can use in C++. I pretend you understand first how each structure works before you look at some code. However, we can’t avoid using some code and I ended adding templates of some structures. This tutorial doesn’t contain all data structures but I’m sure the most important ones are here and this will be a big help in improving your skills in C++.

Array

It’s a collection of elements of the same type directly accessed by an integer index;

Static Array: has a fixed number of elements and it’s allocated during compilation time;

Ex: int x[20];

Dynamic Array: it’s created using allocation techniques and dynamic memory management. Can be resized.

Ex: Int *x = new int [20];

File

It is an external data collection with an associated data structure named by “stream”; Direct Access – files in hard disk; Sequential access – files in tapes;

The reading operation withdraw data from an input stream;
The writing operation merges new data at the end of output stream;

Files are used to save large amounts of data;

Linked List

• Sequential collection of elements;
• No minimum or maximum limit of elements since it is resizable whether the elements are added or removed from the list;
• Doesn’t allow direct access;
• The elements can be disposed through a numeric or alphabetical ordering;
• The elements can be accessed in any position of the list;

The implementation of this structure can be done through an array (the implementation is limited to the array size) or through a Linked List (the structures are created dynamically).

A linked least is composed by nodes. Each node has two fields:
-the object including on the list;
-a pointer to the next element (node) of the list;

Characteristics:
-memory space filled by the list grow accordingly with the needs of the application;
-the operations add() and remove() elements are realized by the local manipulation of the pointers;

A template of the class Linked List that will help a lot:

template< class T>
class List{

    private:
        Node< T>* head;
        void destroylist();

    public:
        List(){head=NULL;};
        List(const List< T>& l);
        ~List();
        bool empty() const{ return head==NULL;};
        void add(int k,const T& elem);
        int lenght() const;
        void remove(int k,T& x);
        bool find(int k, T& x) const;
        const List< T>& operator = (const List< T>& l);
        void write(ostream& out) const;
};

Stack

•the elements are added and removed just by one side of the stack, the top;
•always an element is added or removed of the stack the top is updated;
•it’s a structure where is applied the LIFO order (Last In First Out);

Stacks are used in:
-Evaluation of Numerical Expressions;
-Recursion;

A template for the class Stack:

template< class T>
class Stack{

    private:
        Node< T>* top;
        void destroystack();
        const Stack< T>& invert();

     public:
         Stack(){ top=NULL;}
         Stack(const Stack< T>& s);
         ~Stack();
         bool empty() const{ return top==NULL;};
         void push(const T& elem); //insert an element on the top of the stack
         void pop(T& x); //remove the element on the top of the stack
         const T& top() const{ return top->info;}
         int lenght() const; //return stack lenght
         const Stack< T>& operator = (const Stack< T>& s);
         void write(ostream& ostr) const;
};

Queue

•The access to the elements it’s done using both sides of the queue;
•The elements are “removed” by the front of the queue;
•The elements are “added” by the back of the queue;
•The elements stay always in the same order they arrived which means we have a FIFO type order (First in, First Out);

Queues are used in waiting lists:
-simulation studies;
-Task escalation in operative systems;

Template of class Queue:

template< class T>
class Queue{

    private:
        Node< T>* begin;
        Node< T>* end;
        void destroyqueue();

    public:
        Queue< T>(){ begin=NULL; fim=NULL;};
        Queue< T>(const Queue< T>& q);
        ~Queue< T>();
        bool empty() const{ return begin==NULL;};
        void push_back(const T& elem);
        void pop_front(T& x);
        const T& front() const{ return begin->info;};
        const T& back() const{ return end->info;};
        int lenght() const;
        const Queue< T>& operator = (const Queue< T>& q);
        void write(ostream& ostr) const;
};

Dequeue

•Linear structure more general then the stacks and the queues;
•It’s a special type of queue where the removes and the adds can be done in the front or in the back of the queue;
•Like the queues this structure can be implemented with vector or linked list;

Simple template of Dequeue:

template< class T>
class DQueue: public Queue< T>{

    public:
        DQueue();
        DQueue(const Dequeue< T>& dq);
        ~DQueue();
        void push_front(const T& x);
        void pop_back(T& x);
};

And that’s it for today. Hope you learn something about data structures with this. Now it’s start practicing. Good work!