TweetFollow Us on Twitter

C++ Redux
Volume Number:10
Issue Number:1
Column Tag:Getting Started

Related Info: Color Quickdraw

C++ Redux

Rehashing the basics

By Dave Mark, MacTech Magazine Regular Contributing Author

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Back in the October ‘93 Getting Started column, we took a look at the basics of object programming using C++. Since the column came out, I’ve gotten tons of feedback, from both C++ novices and experts alike. After sorting through all the comments, I took a few days and did a complete rewrite of the October column and of the corresponding chapter (Chapter 5) in Learn C++ on the Macintosh. If you’ve read the first printing of Learn C++ on the Macintosh (the changes will appear in the second printing) or made your way through the first edition of this column, please take the time to read this new version. As a bonus, this month’s column includes a C++ program that demonstrates the techniques described throughout the text (the October column didn’t include a program).

Objects

There is nothing mysterious about the concept of an object. In C++, an object is any instance of a data type. For example, this line of code:

intmyInt;

declares an int object. This column will teach you how to use C++ to create, destroy and manipulate objects in very powerful ways.

The first object we’ll take a look at is the structure.

The Organizational Power of the Struct

One of the most valuable features shared by C and C++ is the structure. Without the structure, you’d have no way to group data that belonged together. For example, suppose you wanted to implement an employee data base that tracked an employee’s name, employee ID, and salary. You might design a structure that looks like this:

const short kMaxNameSize = 20;

struct Employee
{
 char   name[ kMaxNameSize ];
 long   id;
 float  salary;
};

The great advantage of this structure is that it lets you bundle several pieces of information together under a single name. This concept is known as encapsulation.

For example, if you wrote a routine to print an employee’s data, you could write:

EmployeenewHire;
 •
 •
 •
PrintEmployee( newHire.name, newHire.id, newHire.salary );

Did you notice anything unusual about the declaration of newHire in the preceding code sample? In C, this code would not have compiled. Instead, the declaration would have looked like this:

struct Employee  newHire; /* The C version */

When the C++ compiler sees a structure declaration, it uses the structure name to create a new data type, making it available for future structure declarations.

On the other hand, it would be so much more convenient to pass the data in its encapsulated form:

PrintEmployee( &newHire );

Encapsulation allows you to represent complex information in a more natural, easily accessible form. In the C language, the struct is the most sophisticated encapsulation mechanism available. As you'll soon see, C++ takes encapsulation to a new level.

Encapsulating Data and Functions

While C structures are limited strictly to data, C++ supports structures composed of both data and functions.

Here's an example of a C++ structure declaration:

const short kMaxNameSize = 20;

struct Employee
{
// Data members...
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 void   PrintEmployee();
};

This example declares a new type named Employee. You can use the Employee type to declare individual Employee objects. Each Employee object is said to be a member of the Employee class.

The Employee class consists of three data fields as well as a function named PrintEmployee(). In C++, a classes’ data fields are known as data members and its functions are known as member functions.

Each Employee object you create gets its own copy of the Employee class data members. All Employee objects share a single set of Employee member functions.

Later in the column, you’ll see how to access an object’s data members and member functions. For now, let’s take a look at the mechanisms C++ provides to create and destroy objects.

Creating an Object

There are two ways to create a new object. The simplest method is to define the object directly, just as you would a local variable:

Employeeemployee1;

This definition creates an Employee object whose name is employee1. employee1 consists of a block of memory large enough to accomodate each of the three Employee data members.

When you create an object by defining it directly, as we did above, memory for the object is allocated when the definition moves into scope. That same memory is freed up when the object drops out of scope.

For example, you might define an object at the beginning of a function:

void  CreateEmployee()
{
 Employee employee1;

 •
 •
 •
}

When the function is called, memory for the object is allocated, right along with the function’s other local objects. When the function exits, the object’s memory is deallocated.

If you want a little more control over when your object is destroyed, take advantage of C++’s new operator.

First, define an object pointer, then use new to allocate the memory for your object. new returns a pointer to the newly created object. Here’s some code that creates an Employee object:

Employee*employeePtr;

employeePtr = new Employee;

The first line of code defines a pointer designed to point to an Employee object. The second line uses new to create an Employee object. new returns a pointer to the newly created Employee.

Accessing an Object’s Members

Once you’ve created an object, you can modify its data members and call its member functions. If you’ve defined the object directly, you’ll refer to its data members using the . operator:

Employeeemployee1;

employee1.employeeSalary = 200.0;

If you’re referencing the object through a pointer, use the -> operator:

Employee*employeePtr;

employeePtr = new Employee;

employeePtr->employeeSalary = 200.0;

To call a member function, use the same technique. If the object was defined directly, you’ll use the . operator:

Employeeemployee1;

employee1.PrintEmployee();

If you’re referencing the object through a pointer, you’ll use the -> operator:

Employee*employeePtr;

employeePtr = new Employee;

employeePtr->PrintEmployee();

The Current Object

In the previous examples, each reference to a data member or member function started with an object or object pointer. Inside a member function, however, the object or object pointer isn’t necessary to refer to the object for which the member function is executing.

For example, inside the PrintEmployee() function, you can refer to the data member employeeSalary directly, without referring to an object or object pointer:

if ( employeeSalary <= 200 )
 cout << "Give this person a raise!!!";

This code is kind of puzzling. What object does employeeSalary belong to? After all, you’re used to saying:

myObject->employeeSalary
instead of just plain:

employeeSalary

The key to this puzzle lies in knowing which object spawned the call of PrintEmployee() in the first place. Although this may not be obvious, a call to a non-static member function must originate with a single object.

Suppose you called PrintEmployee() from a non-Employee function (such as main()). You must precede this call with a reference to an object:

employeePtr->PrintEmployee();

Whenever a member function is called, C++ keeps track of the object used to call the function. This object is known as the current object.

In the call of PrintEmployee() above, the object pointed to by employeePtr is the current object. Whenever this call of PrintEmployee() refers to an Employee data member or function without using an object reference, the current object (in this case, the object pointed to by employeePtr) is assumed.

Suppose PrintEmployee() then called another Employee function. The object pointed to by employeePtr is still considered the current object. A reference to employeeSalary would still refer to the current object’s copy of employeeSalary.

The point to remember is, a non-static member function always starts up with a single object in mind.

The “This” Object Pointer

C++ provides a generic object pointer, available inside any member function, that points to the current object. The generic pointer has the name this. For example, inside every Employee function, the line:

this->employeeSalary = 400;
is equivalent to this line:

employeeSalary = 400;

this is useful when a member function wants to return a pointer to the current object, pass the address of the current object on to another function, or just store the address somewhere. This line of code:

return this;

returns the address of the current object.

Deleting an Object

When you create an object using new, you’ve got to take responsibility for destroying the object at the appropriate time. Just as a C programmer balances a call to malloc() with a call to free(), a C++ programmer balances each use of the new operator with an eventual use of the delete operator. Here’s the syntax:

Employee*employeePtr;

employeePtr = new Employee;

delete employeePtr;

As you’d expect, delete destroys the specified object, freeing up any memory allocated for the object. Note that this freed up memory only includes memory for the actual object and does not include any extra memory you may have allocated.

For example, suppose the object is a structure and one of its data members is a pointer to another structure. When you delete the first structure, the second structure is not deleted.

Writing Member Functions

Once your structure is declared, you’re ready to write your member functions. Member functions behave in much the same way as ordinary functions, with a few small differences. One difference, pointed out earlier, is that a member function has access to the data members and member functions of the object used to call it.

Another difference lies in the function implementation’s title line. Here’s a sample:

void  Employee::PrintEmployee()
{
 cout << "Employee Name:   " << employeeName << "\n";
}

Notice that the function name is preceded by the class name and two colons. This notation is mandatory and tells the compiler that this function is a member of the specified class.

The Constructor Function

Typically, when you create an object, you’ll want to perform some sort of initialization on the object. For instance, you might want to provide initial values for your object’s data members. The constructor function is C++’s built-in initialization mechanism.

The constructor function (or just plain constructor) is a member function that has the same name as the object’s class. For example, the constructor for the Employee class is named Employee(). When an object is created, the constructor for that class gets called.

Consider this code:

Employee*employeePtr;
employeePtr = new Employee;

In the second line, the new operator allocates a new Employee object, then immediately calls the object’s constructor. Once the constructor returns, the address of the new object is assigned to employeePtr.

This same scenario holds true in this declaration:

Employeeemployee1;

As soon as the object is created, its constructor is called.

Here’s our Employee struct declaration with the constructor declaration added in:

const short kMaxNameSize = 20;

struct Employee
{
// Data members...
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 Employee();
 void   PrintEmployee();
};

Notice that the constructor is declared without a return value. Constructors never return a value.

Here’s a sample constructor:

Employee::Employee()
{
 employeeSalary = 200.0;
}

This is proper form.

Adding Parameters to Your Constructor

If you like, you can add parameters to your constructor. Constructor parameters are typically used to provide initial values for the object’s data members. Here’s a new version of the Employee() constructor:

Employee::Employee( char *name, long id, float salary )
{
 strncpy( employeeName, name, kMaxNameSize );

 employeeName[ kMaxNameSize - 1 ] = '\0';

 employeeID = id;
 employeeSalary = salary;
}

The constructor copies the three parameter values into the corresponding data members.

The object that was just created is always the constructor’s current object. In other words, when the constructor refers to an Employee data member, such as employeeName or employeeSalary, it is referring to the copy of that data member in the newly created object.

This line of code supplies the new operator with a set of parameters to pass on to the constructor:

employeePtr = new Employee( "Dave Mark", 1000, 200.0 );

This line of code does the same thing without using new:

Employeeemployee1( "Dave Mark", 1000, 200.0 );

As you’d expect, this code creates an object named employee1 by calling the Employee constructor, passing it the three specified parameters.

Just for completeness, here’s the class declaration again, showing the new constructor:

struct Employee
{
// Data members...
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 Employee( char *name, long id, float salary );
 void   PrintEmployee();
};

The Destructor Function

The destructor function is called for you, just as the constructor is. Unlike the constructor, however, the destructor is called when an object in its class is deleted or goes out of scope. Use the destructor to clean up after your object before it goes away. For instance, you might use the destructor to deallocate any additional memory your object may have allocated.

The destructor function is named by a tilda character (~) followed by the class name. The destructor for the Employee class is named ~Employee(). The destructor has no return value and no parameters.

Here’s a sample destructor:

Employee::~Employee( void )
{
 cout << "Deleting employee #" << employeeID << "\n";
}

If you created your object using new, the destructor is called when you use delete:

Employee*employeePtr;

employeePtr = new Employee;

delete employeePtr;

If your object was defined directly, the destructor is called just before the object is destroyed. For example, if the object was declared at the beginning of a function, the destructor is called when the function exits.

Here’s an updated Employee class declaration showing the constructor and destructor:

struct Employee
{
// Data members...
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 Employee( char *name, long id, float salary );
 ~Employee();
 void   PrintEmployee();
};

Access Priveleges

When you declare a class, you need to decide which data members and functions you’d like to make available to the rest of your program. C++ gives you the power to hide a classes’ functions and data from all the other functions in your program, or allow access to a select few.

For example, consider the Employee class we’ve been working with throughout the column. In the current model, an Employee’s name is stored in a single array of chars. Suppose you wrote some code that created a new Employee, specifying the name, id, and salary, then later in your program you decided to modify the Employee’s name, perhaps adding a middle name provided while your program was running.

With the current design, you could access and modify the Employee’s employeeName data member from anywhere in your program. As time passes and your program becomes more complex, you might find yourself accessing employeeName from several places in your code.

Now imagine what happens when you decide to change the implementation of employeeName. For example, you might decide to break the single employeeName into three separate data members, one each for the first, middle and last names. Imagine the hassle of having to pore through your code finding and modifying every single reference to employeeName, making sure you adhere to the brand new model.

C++ allows you to hide the implementation details of a class (the specific type of each data member, for example), funneling all access to the implementation through a specific set of interface routines. By hiding the implementation details, the rest of your program is forced to go through the interface routines your class provides. That way, when you change the implementation, all you have to do is make whatever changes are necessary to the classes interface, without having to modify the rest of your program.

The mechanism C++ provides to control access to your classes’ implementation is called the access specifier.

Access Specifiers

C++ allows you to assign an access specifier to any of a classes’ data members and member functions. The access specifier defines which of your program’s functions have access to the specified data member or function. The access specifier must be one of public, private, or protected.

If a data member or function is marked as private, access to it is limited to member functions of the same class (or, as you’ll see later in the chapter, to classes or member functions marked as a friend of the class).

On the flip side, the public specifier gives complete access to the member function or data member, limited only by scope.

By default, the data members and member functions of a class declared using the struct keyword are all public. By adding the private keyword to our class declaration, we can limit access to the Employee data members, forcing the outside world to go through the provided member functions:

struct Employee
{
// Data members...
 private:
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 public:
 Employee( char *name, long id, float salary );
 ~Employee();
 void   PrintEmployee();
};

Once the compiler encounters an access specifier, all data members and functions that follow are marked with that code, at least until another code is encountered. In this example, the three data members are marked as private and the three member functions are marked as public.

The class Keyword

So far, all of our classes have been created using the struct keyword. You can also create classes, using the exact same syntax, substituting the keyword class for struct. The only difference is, the members of a struct are all public by default and the members of a class are all private by default.

Why use class instead of struct? If you start with a struct, you give the world complete access to your class members unless you intentionally limit access using the appropriate access specifiers. If you start with a class, access to your class members is limited right from the start. You have to intentionally allow access by using the appropriate access specifiers.

For the remainder of this book, we’ll use the class keyword to declare our classes. Here’s the new version of the Employee class:

class Employee
{
// Data members...
 private:
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 public:
 Employee( char *name, long id, float salary );
 ~Employee();
 void   PrintEmployee();
};

Notice that the private access specifier is still in place. Since the members of a class-based class are private by default, the private access specifier is not needed here, but it does make the code a little easier to read. The public access specifier is necessary, however, to give the rest of the program access to the Employee member functions.

With all that we’ve covered so far, we’re about ready for our next sample program. Employee.cp brings these concepts together.

An Object Programming Example

Create a new folder named Employee in your development folder. Then, launch Symantec C++ and create a new project, named Employee.Π, in the Employee folder. Next, select Add Files... from the Project menu and navigate into the Symantec C++ for Macintosh folder and then into the Standard Libraries folder. You’ll be adding three libraries to this project. Add the ANSI++, CPlusLib, and IOStreams libraries to the project. When the libraries appear in the project window, drag CPlusLib and IOStreams to a new segment (just click on them, one at a time, and drag them towards the bottom of the project window. The Project Manager will create the new segment for you automatically).

Next, create a new source code file and save it as Employee.cp inside the Employee folder. Add the file to the project. If it doesn’t get added to the same segment as CPlusLib and IOStreams, drag it into that segment. ANSI++ should be in one segment and the three other files should be in a different segment.

Here’s the source code for Employee.cp:

/* 1 */
#include <iostream.h>
#include <string.h>

const short kMaxNameSize = 20;

class Employee
{
// Data members...
 private:
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 public:
 Employee( char *name, long id, float salary );
 ~Employee();
 void   PrintEmployee();
};

Employee::Employee( char *name, long id, float salary )
{
 strncpy( employeeName, name, kMaxNameSize );

 employeeName[ kMaxNameSize - 1 ] = '\0';

 employeeID = id;
 employeeSalary = salary;
 
 cout << "Creating employee #" << employeeID << "\n";
}

Employee::~Employee()
{
 cout << "Destroying employee #" << employeeID << "\n";
}

void  Employee::PrintEmployee()
{
 cout << "-----\n";
 cout << "Name:   " << employeeName << "\n";
 cout << "ID:     " << employeeID << "\n";
 cout << "Salary: " << employeeSalary << "\n";
 cout << "-----\n";
}

intmain()
{
 Employee employee1( "Dave Mark", 1, 200.0 );
 Employee *employee2;

 employee2 = new Employee( "Steve Baker", 2, 300.0 );

 employee1.PrintEmployee();
 employee2->PrintEmployee();

 delete employee2;
 
 return 0;
}

Save your source code, and select Run from the Project menu. Symantec C++ will compile and run your program. Here’s what the output should look like:

/* 2 */
Creating employee #1
Creating employee #2
-----
Name:   Dave Mark
ID:     1
Salary: 200
-----
-----
Name:   Steve Baker
ID:     2
Salary: 300
-----
Destroying employee #2
Destroying employee #1

Let’s take a look at the source code.

The employee Source Code

As you look through employee.cp, you should see some familiar sights. This program takes the Employee class described throughout this column through its paces.

The first thing you’ll notice is the two include files <iostream.h> which is like the C++ version of <stdio.h> (we’ll talk about the iostream library in a later column) and <string.h>, which is needed for the call to strncpy() later in the program:

#include <iostream.h>
#include <string.h>

The const kMaxNameSize and the Employee class declaration are identical to those presented earlier in the column. Notice that the data members are all marked as private (unnecessary, but it does make the code easier to read) while the member functions are marked as public.

const short kMaxNameSize = 20;

class Employee
{
// Data members...
 private:
 char   employeeName[ kMaxNameSize ];
 long   employeeID;
 float  employeeSalary;

// Member functions...
 public:
 Employee( char *name, long id, float salary );
 ~Employee();
 void   PrintEmployee();
};

The Employee class has three member functions: a constructor, a destructor, and a utility routine named PrintEmployee(). The constructor, Employee(), uses its three parameters to initialize each of the Employee data members.

Employee::Employee( char *name, long id, float salary )
{

To avoid a possible non-terminated string in the name parameter, we’ll use strncpy() to copy all the bytes from name into employeeName. strncpy() copies kMaxNameSize characters from name to employeeName. If the name string is less than kMaxNameSize characters long, strncpy() will also copy over the null-terminator.

 strncpy( employeeName, name, kMaxNameSize );

If name is not null-terminated or is kMaxNameSize bytes long or longer, we’ll stick a null-terminator at the very end of employeeName to ensure that one exists.

 employeeName[ kMaxNameSize - 1 ] = '\0';

Finally, we’ll copy the remaining two parameters into their respective data members.

 employeeID = id;
 employeeSalary = salary;

Once the data members are initialized, the constructor sends a message to the console, telling us which Employee object was just created.

 cout << "Creating employee #" << employeeID << "\n";
}

Since no extra memory was allocated, there’s not a whole lot for the destructor to do. Just like the constructor, the destructor sends a message to the console, telling us which Employee object will be deleted.

Employee::~Employee()
{
 cout << "Deleting employee #" << employeeID << "\n";
}

PrintEmployee() displays the contents of the three data members of the current object:

void  Employee::PrintEmployee()
{
 cout << "-----\n";
 cout << "Name:   " << employeeName << "\n";
 cout << "ID:     " << employeeID << "\n";
 cout << "Salary: " << employeeSalary << "\n";
 cout << "-----\n";
}

main() is the control center, where all the action is. First, we define an Employee object, passing three parameters to the constructor:

intmain()
{
 Employee employee1( "Dave Mark", 1, 200.0 );

As the Employee constructor is called, it displays the following line on the console:

Creating employee #1

Next, an Employee object pointer is defined:

 Employee *employee2;

This time, new is used to create a second Employee object:

 employee2 = new Employee( "Steve Baker", 2, 300.0 );

Once again, the Employee constructor is called, sending another line to the console:

Creating employee #2

Now, both objects are used to call the PrintEmployee() member function. employee1 is an object and uses the . operator to access its member function. Since employee2 is a pointer and uses the -> operator to access the PrintEmployee() function:

 employee1.PrintEmployee();
 employee2->PrintEmployee();

These two calls result in the following output:

-----

Name: Dave Mark

ID: 1

Salary: 200

-----

-----

Name: Steve Baker

ID: 2

Salary: 300

-----

Next, the object pointed to by employee2 is deleted:

 delete employee2;
}

This causes employee2’s destructor to be called, resulting in this line of output:

Destroying employee #2

Finally, main() exits and all of main()’s local variables (including employee1) are deallocated. As soon as employee1 was deallocated, its destructor was called, resulting in a final line of output being sent to the console:

Destroying employee #1

Notice that employee1’s destructor wasn’t called till main() had exited.

Take another look at your program’s output. If you like, go run the program again. Notice that every single line of output was produced by an object’s member function. Although you did call PrintEmployee() directly, the constructor and destructor functions were called for you when you created and deleted an object.

Consider the line of code used to delete an Employee object:

delete employee1;

This line of code does not contain a function call. It does not contain code that prints information to the console. Even so, a function call was made (the destructor function, called for you). A line of output was sent to the console.

The point here is that there’s action going on behind the scenes. Stuff happens automatically. You delete an object, the destructor gets called for you. This might seem like a minor point, but this is your first peek at the power of object programming.

Till Next Month

Interested in more C++ coverage? Let me know. You can write to me c/o MacTech magazine at the addresses listed on page 2 of the magazine (Under the heading How to communicate with Xplain Corporation). In the meantime, I’ll go back to the Mac Toolbox and more Color QuickDraw in next month’s column. See you then...

 
AAPL
$94.72
Apple Inc.
+0.78
MSFT
$44.83
Microsoft Corpora
-0.01
GOOG
$594.74
Google Inc.
+5.27

MacTech Search:
Community Search:

Software Updates via MacUpdate

Airmail 1.4 - Powerful, minimal email cl...
Airmail is a powerful, minimal mail client.It was designed to retain the same experience with a single or multiple accounts and provide a quick, modern and easy-to-use user experience. Airmail... Read more
Macs Fan Control 1.1.12 - Monitor and co...
Macs Fan Control allows you to monitor and control almost any aspect of your computer's fans, with support for controlling fan speed, temperature sensors pane, menu-bar icon, and autostart with... Read more
A Better Finder Rename 9.37 - File, phot...
A Better Finder Rename is the most complete renaming solution available on the market today. That's why, since 1996, tens of thousands of hobbyists, professionals and businesses depend on A Better... Read more
MacBook Air EFI Firmware Update 2.9 - Fo...
MacBook Air EFI Firmware Update is recommended for MacBook Air (Mid 2011) models. This update addresses an issue where systems may take longer to wake from sleep than expected and fixes a rare issue... Read more
FileZilla 3.9.0.1 - Fast and reliable FT...
FileZilla (ported from Windows) is a fast and reliable FTP client and server with lots of useful features and an intuitive interface.Version 3.9.0.1: MSW: Fix installation issue with locked DLLs... Read more
OS X Yosemite 10.10 DP4 - Developer Prev...
Note: This is a Developer Preview. You must be a registered Apple Mac Developer to download this update. OS X Yosemite is Apple's newest operating system for Mac. An elegant design that feels... Read more
FinderPop 2.5.6 - Classic Mac utility, n...
FinderPop is a Universal preference pane that extends OS X's contextual menus using a FinderPop Items folder much as the Apple Menu Items folder used to do for the Apple menu. It has other features... Read more
SpiderOak 5.1.7 - Secure cloud backup, s...
SpiderOak is a multi-platform secure online backup, storage, access, and sharing solution engineered for the consumer and small businesses. You must first sign up to use SpiderOak. Running natively... Read more
Espionage 3.6 - Simple, state of the art...
Espionage offers state-of-the-art encryption and plausible deniability for your confidential data. Sometimes, encrypting your data isn't enough to protect it. That's why Espionage 3 goes beyond data... Read more
calibre 1.45.0 - Complete e-library mana...
Calibre is a complete e-book library manager. Organize your collection, convert your books to multiple formats, and sync with all of your devices. Let Calibre be your multi-tasking digital... Read more

Latest Forum Discussions

See All

Celebrate Summer With a Cat in the Hat L...
Celebrate Summer With a Cat in the Hat Learning Library Sale Posted by Ellis Spice on July 22nd, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
MyTaskList Review
MyTaskList Review By Jennifer Allen on July 22nd, 2014 Our Rating: :: EFFECTIVE IF PLAINUniversal App - Designed for iPhone and iPad It’s not the most stylish of task management apps, but MyTaskList has all the features you could... | Read more »
FlyCraft Herbie: Crazy Machines Review
FlyCraft Herbie: Crazy Machines Review By Jennifer Allen on July 22nd, 2014 Our Rating: :: TRICKY FLYINGUniversal App - Designed for iPhone and iPad A tough game of careful thrusting and navigation, FlyCraft Herbie: Crazy Machines... | Read more »
MTN Review
MTN Review By Jessica Fisher on July 22nd, 2014 Our Rating: :: ADORABLE, SERENE, AND AMUSINGUniversal App - Designed for iPhone and iPad MTN is an adorable, talking pet mountain that is less game and more zen garden.   | Read more »
Fly High with Ninja UP! Now Available o...
Fly High with Ninja UP! Now Available on the App Store Posted by Jessica Fisher on July 22nd, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Bio Inc. Review
Bio Inc. Review By Nadia Oxford on July 22nd, 2014 Our Rating: :: SICKENING - IN A COMPELLING WAYUniversal App - Designed for iPhone and iPad Bio Inc is about orchestrating the medical destruction of a single person. If that doesn’... | Read more »
HELMUT Review
HELMUT Review By Andrew Fisher on July 21st, 2014 Our Rating: :: TRUNDLE SIMULATOR 2014Universal App - Designed for iPhone and iPad HELMUT is a fun, fleeting time-sink that offers a momentary distraction and nothing else.   | Read more »
Walkr Review
Walkr Review By Jennifer Allen on July 21st, 2014 Our Rating: :: ORIGINAL WALKINGiPhone App - Designed for the iPhone, compatible with the iPad Walking is a bit more exciting thanks to this planet building/discovering sim reliant... | Read more »
Zombie Commando Review
Zombie Commando Review By Jennifer Allen on July 21st, 2014 Our Rating: :: MINDLESS SLAUGHTERUniversal App - Designed for iPhone and iPad Briefly fun but ultimately forgettable, Zombie Commando will scratch an itch then be... | Read more »
Swords & Poker Adventures Review
Swords & Poker Adventures Review By Jennifer Allen on July 21st, 2014 Our Rating: :: SOULLESS POKER PLAYUniversal App - Designed for iPhone and iPad Swords & Poker Adventures is a mishmash of Poker and RPGing, but it lacks... | Read more »

Price Scanner via MacPrices.net

15-inch 2.0GHz MacBook Pro Retina on sale for...
B&H Photo has the 15″ 2.0GHz Retina MacBook Pro on sale for $1829 including free shipping plus NY sales tax only. Their price is $170 off MSRP. B&H will also include free copies of Parallels... Read more
Apple restocks refurbished Mac minis for up t...
The Apple Store has restocked Apple Certified Refurbished Mac minis for up to $150 off the cost of new models. Apple’s one-year warranty is included with each mini, and shipping is free: - 2.5GHz Mac... Read more
Twelve South HiRise For MacBook – Height-Adju...
If you use your MacBook as a workhorse desktop substitute, as many of us do, a laptop stand combined with an external keyboard and pointing device are pretty much obligatory if you want to avoid... Read more
Why The Mac Was Not Included In The Apple/IBM...
TUAW’s Yoni Heisler cites Fredrick Paul of Network World whoi blogged last week that the Mac’s conspicuous absence from Apple and IBM’s landmark partnership agreement represents a huge squandered... Read more
Save $100 on 13-inch Retina MacBook Pros, plu...
Adorama has 13″ Retina MacBook Pros on sale for $100 off MSRP. Shipping is free, and Adorama charges sales tax in NY & NJ only: - 13″ 2.4GHz/128GB MacBook Pro with Retina Display: $1199 - 13″ 2.... Read more
Blurr it 2.3 for iOS – Quickly Blurs Selected...
Hyderabad, India based TouchLabs has announced a new update of Blurr it 2.3, their photography app for iOS users. Blurr it allows you to blur part of the image to hide potentially sensitive or... Read more
MacBook Airs on sale for $100 off MSRP, start...
Best Buy has the new 2014 MacBook Airs on sale for up to $100 off MSRP on their online store. Choose free home shipping or free local store pickup (if available). Prices valid for online orders only... Read more
Amazon Announces Kindle Unlimited: Unlimited...
Amazon.com has introduced Kindle Unlimited — a new subscription service which allows customers to freely read as much as they want from over 600,000 Kindle books, and listen as much as they want to... Read more
New Linksys Wireless Range Extenders Boost Wi...
Linksys has announced its new lineup of Linksys Wi-Fi Range Extenders. Consumers often experience a weak wireless signal in some parts of their house or apartment caused by blocking elements such as... Read more
MacBook Airs available starting at $719
The Apple Store has Apple Certified Refurbished 2013 & 2012 MacBook Airs in stock today starting at $719. An Apple one-year warranty is included with each MacBook, and shipping is free: 2013... Read more

Jobs Board

*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Sr *Apple* Engineer - IT - Requisition #: -...
For more information about TIAA-CREF, visit our website . The Apple Engineer will provide engineering and third-level incident support for 300- 500 MacOS desktop/laptop Read more
*Apple* Systems Administrator - DISH (United...
…satellite service provider, and Dish is currently looking for an experienced Apple /Mac Systems Administrator. Apple systems administrator will be responsible for Read more
*Apple* Systems Administrator - DISH (United...
…satellite service provider, and Dish is currently looking for an experienced Apple /Mac Systems Administrator. Apple systems administrator will be responsible for Read more
*Apple* /MAC Systems Administrator - Tekkies,...
Title: Apple /Mac Systems Administrator Location: Englewood, CO Term: Permanent Placement Description Our client is currently looking for an experienced Apple /Mac Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.