Prash's Tech Blog

BMTC & Android

2011-05-25T18:31:00.003+05:30

Recently, I noticed interactive display panels on BMTC - Vayu Vajra (BIA) Volvo bus, while commuting to office (Hebbal to Marathhalli). I’m really excited to say that these are powered by Google’s Android Operating System.

Good part is, it includes a "Webkit" browser for free internet browsing while you travel. What else you want when you are stuck in traffic? :)

I could confirm that its using Android OS and Webkit browser by examining the UserAgent:

Mozilla/5.0(Linux; U; Android 2.1-update1; en-us; Generic Build/ECLAIR) AppleWebkit/530.17 (KHTML, like Gecko) Version/4.0 Mobile Safari/530.17

See below snapshot.

Along with the in-built browser, it also lists few useful apps - Youtube, facebook, Sudoku, Weather, Stocks, News etc.

For me, these apps looks to be web-apps which are non-native and not even Java based.

Advertising is another interesting aspect.
The lower part of the display has local retailer advertisements. BMTC may be earning a good revenue out of it. :)

Overall experience of using internet on BMTC Vayu Vajra was awesome! I'm really amazed by abilities of Android as a platform. Its not just phone anymore.

You may not be surprised to see these devices one day in your car. :)
I'll wait for that day!

The Age of ‘WebApps’

2010-10-31T02:07:00.005+05:30

Looks like there is a big paradigm shift from ‘native’ apps to so-called ‘WebApps’ nowadays!

Listing the WebApps which I personally use in daily life and like the most.

Do you come across any? Let me know!

	Store, Sync, Share files online.
	Password Manager.
	To-Do list manager.
	Remember everything on any device.
	Instant messaging program which supports multiple IM services.
	Creates social media players for cellphones and handheld devices with huge library of lyrics.
	Save Pages to Read Later. Offline reading!
	Web videos!
	Great feeds reader from Google.
	Twitter!
	Wiki.
	Bookmark manager.
	Geo-tagging.
	Create floor plans, house plans and home plans ‘online’.
	facebook!

no service found for - "com.nokia.qt.mediaplayer"

2010-10-24T10:18:00.003+05:30

Of late, I was trying to build QtMobility on Ubuntu, specifically experimenting with QtMultimedia feature set.

In the process, I stumbled on this (not so) strange issue which frustrated me for a log time. I was using Qt4.7 + QtMobility v1.1.0 Beta.

Building QtMobility was not an issue. However, when I tried to play a multimedia content in demo/player app , it just couldn't play it complaining :

no service found for - "com.nokia.qt.mediaplayer"

It was clearly a mistake of mine not having a look at the 'configure' warning messages :

Reading /home/pranaray/qt-mobility-opensource-src-1.1.0-beta2/plugins/multimedia/multimedia.pro
Project MESSAGE: QtMultiMedia checking for gstreamer...
Package gstreamer-0.10 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gstreamer-0.10.pc' to the PKG_CONFIG_PATH environment variable
No package 'gstreamer-0.10' found
Package gstreamer-base-0.10 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gstreamer-base-0.10.pc' to the PKG_CONFIG_PATH environment variable
No package 'gstreamer-base-0.10' found
Package gstreamer-interfaces-0.10 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gstreamer-interfaces-0.10.pc' to the PKG_CONFIG_PATH environment variable
No package 'gstreamer-interfaces-0.10' found
Package gstreamer-audio-0.10 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gstreamer-audio-0.10.pc' to the PKG_CONFIG_PATH environment variable
No package 'gstreamer-audio-0.10' found
Package gstreamer-video-0.10 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gstreamer-video-0.10.pc' to the PKG_CONFIG_PATH environment variable
No package 'gstreamer-video-0.10' found

The message was clearly warning about the missing gstreamer library packages.
I had to install libgstreamer0.10-dev & libgstreamer-plugins-base0.10-dev packages to resolve the issue.

sudo apt-get install libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev

I also installed few additional gstreamer plugins along with the above said packages to be able to play mp3 and other media content formats.

Bypassing Same-Origin policy on Firefox.

2010-08-24T19:36:00.002+05:30

Same-origin policy is an essential feature implemented in most of the modern browsers to shield against malicious scripts execution. It simply blocks javascripts belong to domains other than the one which is currently being executed.

However, for development and testing of mash-ups, web apps or widgets, its sometimes required to disable this, so that a local javascript of my widget could reach Twitter or Foursquare webserver to pull the data via AJAX.

Firefox as a leader desktop browser simply block such attempts denying the cross origin AJAX requests.

Fortunately, Firefox’s settings are configurable and it allows us to disable such restrictions so that it can bypass the Same-origin policy.

Here is a brief summary of what I discovered for achieving this. Special thanks to Raghava for helping me out to reach to it.

Step-1

Launch Firefox browser, navigate to "about:config".
Set the property "security.fileuri.strict_origin_policy" to “false”

Step-2

Update the javascript by add this line before creating any XHR request:

netscape.security.PrivilegeManager.enablePrivilege(”UniversalBrowserRead”);

Example :

// Enable Universal Browser Read
try{

netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead");

}
catch(e){

alert(e);

}

// create XmlHttpRequest Object
var xmlhttp = new XMLHttpRequest();

That's it! You are now all set to access any cross origin resource from a local web app running on Firefox.

Please remember to revert this setting back so that your web is back to safe mode :)

Building QtWebKit on Windows – Few common issues

2010-07-11T18:26:00.003+05:30

In continuation to my last blog entry, here I’m trying to capture few common problems that I encountered along with possible solutions for them, in the process of building QtWebKit for windows.

Listing out issues and followed by possible solution for them:

1. ERROR: qmake missing but required to build WebKit.

Make sure QTDIR env variable is set and PATH variable includes path to Qt bin folder.

set QTDIR=C:\Qt\4.6.3

set PATH=%PATH%;%QTDIR%\bin;

2. ERROR: flex, bison, gperf missing but required to build WebKit.

Have you installed GNUWin32 tools? Also, include GNUWin32 bin path under PATH env variable.

set PATH=%PATH%;C:\GnuWin32\bin;

3. 'nmake' is not recognized as an internal or external command

Make sure you have installed MS Visual Studio. Also try running the webkit build script from within Visual Studio 2008 Command Prompt.

4. Failed to generate WebCore's derived sources!Can't locate Switch.pm in @INC

Is Active Perl installed? Active Perl v5.10 or higher is required. Update PATH env variable with perl bin folder paths.

set PATH=C:\Perl\site\bin;C:\Perl\bin;%PATH%

5. Cannot open include file: 'windows.h': No such file or directory

Microsoft Platform SDK need to be installed. INCLUDE and LIB env variables need to be updated.

set INCLUDE=%INCLUDE%;C:\Program Files\Microsoft SDKs\Windows\v6.0\Include

set LIB=%LIB%;C:\Program Files\Microsoft SDKs\Windows\v6.0\Lib

6. JavaScriptCore\DerivedSources\chartables.c (13) : error C2466: cannot allocate an array of constant size 0

This issue arises because of usage of wrong version of perl to generate derived sources.

To solve this issue, we need to install Active Perl v5.10 and regenerate derived sources. For regenerating the derived sources, delete the ‘WebKitBuild’ folder and restart the build by launching the ‘build-webkit’ script again.

7. LINK : fatal error LNK1210: exceeded internal ILK size limit; link with /INCREMENTAL:NO

Not sure why visual studio crib with such a linker error. As a quick solution, we need to disable incremental linking.

Update webkit.pri by adding linker flag to disable incremental linking:

QMAKE_LFLAGS += /INCREMENTAL:NO

Restart the build by launching the ‘build-webkit’ script again.

Building QtWebKit on Windows

2010-07-11T18:16:00.002+05:30

Intention of this and the following blog entries is to record my experiences while building QtWebKit on Windows with MS Visual Studio 2008. I’ve tried to gather few common issues and solutions for them which I came across in the process of compilation.

Which compiler?

I opted for Microsoft Visual Studio 2008 as I had it already installed on my laptop.

However, QtWebKit building instructions indicate that we can use either MSVS or MinGW.

Note that, rest of this article only talks about using MS Visual Studio (nmake) as the compiler. If you are willing to choose MinGW, please follow instructions here.

Windows Platform SDK

Download and install Windows Platform SDK. Make sure INCLUDE env variable has the SDK include path:

ex : C:\Program Files\Microsoft SDKs\Windows\v6.0\Include

and LIB env variable includes SDK lib path.

ex : C:\Program Files\Microsoft SDKs\Windows\v6.0\Lib

Active Perl v5.10

Install Active Perl later than v5.10 from here. Ensure PATH variable includes:

C:\Perl\bin;C:\Perl\site\bin

Qt for Windows SDK

Download and install latest available Qt for windows from http://qt.nokia.com/downloads. Qt can either be downloaded as an SDK or as precompiled binary set.

When I downloaded SDK, I noticed that the SDK binaries were compiled with MinGW. This means, its incompatible with my MSVC compiler. So, I had to rebuild Qt source from scratch after installing Qt SDK.

As an alternative to this approach, we can download and install Qt binaries which are precompiled with MSVC.

Luckily Qt provides prebuilt binaries compiled with both MinGW and MSVC-2008. You can choose either of that, based on the compiler you are using.

Ensure QTDIR env variable is created and pointing to Qt install folder.

ex : QTDIR=C:\Qt\4.6.3

Also, PATH variable need to include the Qt binary path:

C:\Qt\4.6.3\bin

GNUWin32 tools

Download and install following GNUWin32 tools :

Include install path under PATH env variable (ex: C:\GnuWin32\bin)

Checking out WebKit source

Check out source from WebKit SVN trunk http://svn.webkit.org/repository/webkit/trunk

I experienced a glitch while checking out webkit repository. Have a look at my previous blog entry for more info on that.

Building QtWebkit

Now, we are ready with all the pre-requisites. To build QtWebKit, we need to run build-webkit script passing –-qt and -–debug or --release parameters.

Following script execution builds the release version of QtWebKit binaries:

perl WebKitTools\Scripts\build-webkit --qt --release

for debug version of binaries :

perl WebKitTools\Scripts\build-webkit --qt --debug

References

http://trac.webkit.org/wiki/BuildingOnWindows
http://trac.webkit.org/wiki/BuildingQtOnWindows
http://webkit.sed.hu/blog/20091027/building-qtwebkit-windows
http://webkit.org/building/build.html
http://webkit.org/building/tools.html

Excluding folders while checking out an SVN repository

2010-07-04T14:10:00.002+05:30

Blogging this entry out of frustration of not finding an easier way to exclude selected folders while ‘svn checkout’ing a huge svn repository.

I had to checkout all folders from webkit trunk repository except this folder – LayoutTests, which was not really necessary for my work. I was not interested in downloading it, as it was really huge and could consume lots of time and bandwidth in downloading it.

Unfortunately ‘svn:ignore’ couldn’t helped me in achieving this as I was thinking earlier :(. ‘svn:ignore’ is meant only for ignoring files/folders while committing/adding them to repository, but not for checking out or updating a repository.

After googling for a while came to know that only way of achieving this is to use Sparse Checkouts feature which was introduced since SVN v1.5.

However, solution is not straight forward. we have to checkout with an option of --depth=immediates which would checkout all files and folders (excluding everything from sub-folders). Then ‘svn up’ individual folder which we are interested in.

I was really not satisfied by this solution. This doesn’t help much in addressing the problem if we do have large number of folders and are in different levels in folder hierarchy.

Can this be a new feature for svn toolset? or do any one have a better approach for this problem? Let me know.

Swap space on Ubuntu

2010-01-17T11:15:00.002+05:30

Had to compile Qt on Ubuntu virtual machine running on Win XP. Compilation used to fail repeatedly for QtGui component with the following error:

collect2: ld terminated with signal 9 [Killed]

With not much error information, I was clueless on what was going wrong!

Google’ing this error resulted me to learn that swap space reserved was too less (or not at all reserved?) which was required for Qt compilation.

Then tried using the swapon utility command to check how much swap space is already reserved:

sudo swapon –s

Found that nothing was listed at all!

Executed the following commands to create a swap space of 512MB.

sudo dd if=/dev/zero of=/mnt/512Mb.swap bs=1M count=512
sudo mkswap /mnt/512Mb.swap
sudo swapon /mnt/512Mb.swap

This reserved 512MB of swap space, which solved my Qt compilation issues.

reference : https://help.ubuntu.com/community/SwapFaq

Developing Applications with Nokia WRT - VTU EduSat ppt

2009-10-17T11:35:00.007+05:30

Check out this SlideShare Presentation on Developing Applications with Nokia Web Runtime.
This was broadcasted live to all VTU colleges in Karnataka on 14th Sept 2009 as part of VTU's EDUSAT programme.

My self and Raghava had an opportunity to represent Nokia's Web Runtime.
We tried to present the latest developments in Nokia's WebRuntime.

Dependency Walker for Windows binaries

2009-09-06T22:04:00.002+05:30

I find Dependency Walker a very useful utility. This helps us to scan any of windows binaries (exe, dll ...).

It can dissect almost any type of windows binary file, to show up all possible details hidden within.

Listing few of the details this utility can provide,

Basic binary properties Ex: physical path, version info, etc.
Exported functions with their signatures and ordinal numbers.
Recursive list of dependent libraries and their details.

It didn’t took much time for me to discover the power of this tiny tool which is distributed as apart of MS Visual Studio Tools. This can also be downloaded for free at http://www.dependencywalker.com/.

Below is one of such situation, where this tool helped me to rapidly identify and debug the problem.

I was building Qt for Win with ‘-openssl-linked’ option and this required me to download the openSSL libraries separately. I had downloaded and copied ‘libeay32.dll’ under Qt’s bin folder.

Even though Qt compiled without any problems, I had issues with launching few of the processes which had dependency over libeay32.dll. For some reasons, loader started complaining about missing ordinal in libeay32.dll.

Dependency walker came into rescue. I simply loaded the failing process into DependencyWalker and it listed all dependent DLLs with respective details. I could just walk to the libeay32.dll and examine its version.

There you go! It was loading an older version of DLL which had been installed as part of Wireless monitor app. Since PATH variable had the wireless app’s path occurring before Qt’s bin path, it was always picking the older DLL from wrong location which caused the issue.

It hardly took me few minutes to identify and fix the issue.

Hope this is useful :)

HTML5 video

2009-08-13T08:50:00.002+05:30

Just wanted to embed a video using HTML5 video feature. The source looks very simple!

<video controls="controls" src="http://tinyvid.tv/file/3ifyc1xrvwkjr.ogg" tabindex="0">
   <p>
   Sorry, your browser doesn't support the <video> element. You'll need a browser that can playback Ogg media using HTML5 video and audio tags.
   </p>
</video>

This tries to embed one of my favorite music video – In the Shadows by The Rasmus :)

Sorry, your browser doesn't support the element. You'll need a browser that can playback Ogg media using and .

Please use the latest versions of Chrome or Firefox to experience the embedded video. The latest versions of Chrome and Firefox are already supporting the HTML5 video and audio features.

Have fun!

Reference : HTML5 spec

Resolving the exported symbols from a Symbian DLL

2009-07-22T20:34:00.002+05:30

Symbian OS optimizes DLL program code to save ROM and RAM space, by offering only "lookup by ordinal" and not "lookup by name".

Symbian OS does not offer “lookup by name” because this adds an overhead to the size of the DLL (storing the names of all the functions exported from the library is wasteful of space). Instead, Symbian OS only uses link by ordinal, which has significant implications for binary compatibility.

If we are loading a DLL dynamically and need to resolve a exported function address, we need to use the following RLibrary API, which takes an integer parameter representing the ordinal number of the exported function.

TLibraryFunction RLibrary::Lookup(TInt anOrdinal)

Luckily, as part of POSIX for Symbian (P.I.P.S), widely known as Open-C library, we can achieve “lookup by name” with a Symbian DLL.

This is possible only if the library is built as STDDLL.

This allows us to have the POSIX like behavior for resolving the exported DLL symbols even on Symbian. Following POSIX like APIs can be used on Symbian provided the DLL is built as STDDLL.

void *dlopen(const char *filename, int flag);
void *dlsym(void *handle, const char *symbol);
void dlclose(void *handle);

An example with source using the PIPS libraries is here.

Digest authentication with Apache

2009-05-31T23:58:00.003+05:30

This article is in continuation with previous and talks about setting up digest authentication with Apache.

There are few changes compared to the steps for Basic authentication.

1. Generating the password file for digest auth.

htdigest -c digest.txt secret prash

digest.txt is the password file, secret - the realm and prash is the username.

2. Create htaccess.acl under c:\wamp\www\digest-auth\ with following data

AuthUserFile C:\wamp\bin\apache\Apache2.2.11\bin\digest.txt
AuthName "Protected by Digest auth"
AuthType Digest
AuthDigestProvider file

<Limit GET POST>
require valid-user
</Limit>

‘AuthDigestProvider file’ is an additional property that needs to be mentioned for proper working of digest authentication.

3. And, last but not the least. Enable auth_digest_module by un-commenting the following line if its already commented in httpd.conf.

LoadModule auth_digest_module modules/mod_auth_digest.so

Reference : http://httpd.apache.org/docs/2.2/mod/mod_auth_digest.html

Setting up HTTP Basic authentication with Apache

2009-05-31T22:47:00.003+05:30

Last week, I had a chance to setup our test Apache server for Basic and Digest authentication. The setup was required to verify few of the HTTP authentication related test cases.

I’m blogging it here so that I’ll not forget, if I need it again :)

I had WAMP Server v2.0 which included Apache v2.2.11 web server.

Setting up Basic authentication was straight forward.

1. Update http.conf by adding :

AccessFileName htaccess.acl .htaccess

An htaccess file can be used to modify the Apache configuration on a per-directory basis.

On some operating systems ‘htaccess.acl’ is not required. Ex, on Linux, you can just mention it as .htaccess. This is because, on Linux you can create a file with name .htaccess.

2. Add “Directory” tag into http.conf as shown below :

<Directory "c:/wamp/www/basic-auth/">
    Options None
    AllowOverride all
    Order Deny,Allow
</Directory>

c:/wamp/www/basic-auth/ is the folder which needs to be secured by the authentication scheme which we are trying to impose.

3. Next step is to create password file.

cd C:\wamp\bin\apache\Apache2.2.11\bin
htpasswd -c pwd.txt prash

This prompts for the password for the username – ‘prash’. After supplying the password we will be ready with the password file – ‘pwd.txt’ under ‘C:\wamp\bin\apache\Apache2.2.11\bin’.

4. Create the htaccess file - ‘htaccess.acl’ file with the following data.

AuthUserFile C:\wamp\bin\apache\Apache2.2.11\bin\pwd.txt
AuthName "Protected"
AuthType Basic

<Limit GET POST>
require valid-user
</Limit>

This specifies which password file need to be considered for the authentication – ‘C:/wamp/bin/apache/Apache2.2.11/bin/pwd.txt’ also the type of authentication scheme – Basic.

Place this file under the folder ‘c:/wamp/www/basic-auth/’ along with other live data and restart the server.

Now, try accessing the folder http://localhost/basic-auth. This should prompt for username and password.

Reference : http://httpd.apache.org/docs/2.2/mod/mod_auth_basic.html

Making my blog 'Mobile Friendly'

2009-05-02T11:18:00.003+05:30

Being part of mobile software industry and that too working for S60 Browser research team, I desperately wanted to make my blog mobile friendly.

Unfortunately Blogger, where this blog is hosted lacks this service. This would be a very nice and really useful feature.

Wordpress seems to offer this already - http://wordpressmobile.mobi/.

After I did some googling I came across MoFuse. Mofuse provides feeds based solution to convert your blogs to mobile readable version.

Setting up a mobilized version with MoFuse was pretty straight forward, I just registered for a new mobilized blog URL - http://prashtech.mofuse.mobi which internally points to my blogs' RSS feeds.

That's it. If any of you visiting my blog from your mobile, try the mobilized version of my Blog!

http://prashtech.mofuse.mobi.

Backward Compatibility with DLLs – Part 2 (Private Implementation)

2009-01-11T21:36:00.004+05:30

A very Happy New Year to all of the readers!

This article is in continuation with the previous one, about preserving DLL exported APIs’ backward compatibility.

The last article described a technique of achieving this by privatizing the API’s constructor. This has many disadvantages of its own, as the c’tor is private, ex: Object can not be instantiated on stack.

An alternative technique is to have a “Private Implementation”.

If you have a class, which you intend to export, separate out all the internal implementation including the data members and the functions which you think can be hidden. The exported class will only have the functions exported along with a private member pointer to the new internal class.

As an example, consider the following class,

#define DLL_EXPORT __declspec(dllexport)
class DLL_EXPORT ExampleExport
{
public: // c'tors and d'tors
    ExampleExport();
    ~ExampleExport();

public: // functions
    void function1();
    int function2();

private: // private data members
    int m_member1;
    int m_member2;
};

We have 2 integer member variables. Adding or removing the member variables later, will always cause a binary compatibility break as described in the previous article.

Let’s try to separate out the internal implementation. We will move all the private data members to a different class – ExampleExportPrivate.

class ExampleExportPrivate
{
public: // c'tors and d'tors
    ExampleExportPrivate();
    ~ExampleExportPrivate();

public: // data members
    int m_member1;
    int m_member2;
};

We will redefine ExampleExport to use ExampleExportPrivate.

#define DLL_EXPORT __declspec(dllexport)

class ExampleExportPrivate; // <<-- forward declaration of the private implementation which is defined in cpp file

class DLL_EXPORT ExampleExport
{
public: // c'tors and d'tors
    ExampleExport();
    ~ExampleExport();

public: // functions
    void function1();
    int function2();

private:
    ExampleExportPrivate *m_private; // <—Pointer to private implementation. };

As a first step, forward declare the private implementation class – ExampleExportPrivate. The actual definition of this private implementation class can be placed as part of the cpp file. So, we are not exposing this class outside, even in the header files exported. Next step is to have a private pointer member variable which points to ExampleExportPrivate. Any references to the data will be redirected to the internal private implementation.

This technique will help us to not change the size of the exported class. If we need to add or delete a new member variable, ExampleExportPrivate will be the class which will have those changes, but not ExampleExport.

This technique is usually called as “PImpl” (Private Implementation). Here is an interesting article http://www.gotw.ca/publications/mill04.htm

Backward Compatibility with DLLs

2008-12-01T00:11:00.003+05:30

This and the following articles, I personally feel very interesting.

It’s related to the “backward compatibility” of the DLLs.

If you are distributing your DLLs to people or 3rd party, whom you expect to use them, you should be very careful about the interface you expose out of the DLLs.

Consider you are distributing a DLL, which has an exported class of some size and few public functions. If you update the same DLL in future and redistribute it, you cannot always expect the users to re-link their application with your new DLL. In such cases, users of the DLL expect the same interface what you had provided in the earlier release. If by any way there is a change in the interface, it results in failure of backward compatibility.

Let’s take an example to explain this situation. The following is a class which you are exporting as part of your DLL,

#define DLL_EXPORT __declspec(dllexport)

class DLL_EXPORT ExampleExport
{
    public:
        ExampleExport();
        ~ExampleExport();

        void function1();
        int function2();

    private:

        int m_member1;
        int m_member2;
};

In a future release you updated this class to have an additional member variable,

class DLL_EXPORT ExampleExport
{
    public:
        ExampleExport();
        ~ExampleExport();

        void function1();
        int function2();

    private:

        int m_member1;
        int m_member2;
        int m_member3; // <<---- a new member variable added
};

You can observer that the class size has been changed. Earlier it was 8 bytes (assuming int as 4 bytes) and it’s changed to 12 by adding an additional integer member variable.

Consequence: For an end user application, which is not re-linked with the updated DLL, the size of the class is still 8 bytes. Since the application was compiled and linked with the first version of DLL, the size is still the same even after they started using the new DLL. The application may have unpredicted behavior.

Resolution: This problem needs to be addressed before we release the first version of the DLL. Of course we cannot restrict the size of the class to not to change in future. We may need to update it by adding or removing new member variables. One solution is to force the end user application to not to construct the object by itself.

Make constructor private.
Export a new static member function which creates an object by calling private constructor

class DLL_EXPORT ExampleExport
{
public:
    ~ExampleExport();

public:
    static ExampleExport* Instance();

public:
    void function1();
    int function2();

private:
    ExampleExport(); // <<---- private constructor

private:
    int m_member1;
    int m_member2;
    int m_member3; // <<---- a new member variable added
};

This forces the client application to use ExampleExport::Instance() function always to construct an object and since the definition of Instance() is part of the DLL, 12 bytes will be allocated with the new DLL.

Let’s have a look at another solution for the same problem, in the next article.

Forward Declarations

2008-06-01T22:34:00.002+05:30

We can use forward declaration to speedup the compilation and to reduce the interdependencies between different modules.

Consider following CServer and CClient classes, declared in Server.h and Client.h header files respectively.

Server.h

#include "Client.h"
class CServer
{
public:
    CServer();
    virtual ~CServer();
    void SendMsg(CClient &clnt);
private:
    CClient *m_ptrClient;
};

In this case it will always be more efficient to omit the inclusion of the header file Client.h, instead we can use forward declaration as shown below,

class CClient;
class CServer
{
public:
    CServer();
    virtual ~CServer();
    void SendMsg(CClient &clnt);
private:
    CClient *m_ptrClient;
};

This is sufficient in this case because of the reason that C++ compiler is optimized enough and it doesn't need to know about the size and interfaces of the class CClient within the declaration of the CServer class.

However we have to include the Client.h header in Server.cpp where the actual definition of the member functions exist.

Below are some use cases which indicates the usage of forward declarations,

class CClient;
class CServer
{
public:
    CServer();
    virtual ~CServer();
    void SendMsg(CClient clnt); // non-ref/pointer parameter
private:
    CClient *m_ptrClient;
};

Usage of forward declaration is valid even though we have non-reference or non-pointer parameter in the member function.

Below is a case where we cannot use forward declaration,

class CClient;
class CServer
{
public:
    CServer();
    virtual ~CServer();
    void SendMsg(CClient clnt) { clnt.updateMsg(); } // inline definition
private:
    CClient *m_ptrClient;
};

Cannot use forward declaration here because SendMsg has it's inline definition which is actually using CClient::updateMsg(). In this case we need to include the header Client.h within Server.h

One more case where we can not use forward declaration,

class CClient;
class CServer
{
public:
    CServer();
    virtual ~CServer();
    void SendMsg(CClient clnt);
private:
    CClient m_client;
};

Since the member variable m_client within CServer is of type CClient, compiler need to know about the CClient. We cannot use the forward declaration here.

Rule of Thumb : "If the compiler doesn't need it, you won't have to do it." C++ is well optimized.

dynamic_casting with pointers and references

2008-01-09T00:48:00.003+05:30

First of all a very warm happy new year to all the readers. Its been a while since the last post.

Today I intend to write about dynamic_cast again. There's already an article about dynamic_cast. The reason why I'm writing about this is to show with some samples how we can use dynamic cast with pointers and also with references.

Yes, RTTI can be implemented both with pointers and references.

Below sample shows how to use dynamic_cast with pointers. I have considered the same example classes which were there in the dynamic_cast article .

void ProcessButtonEvent(CControlIface *pControl)
{
    // Here we need make sure safe down-cast happens
    CButtonControl *pButton = dynamic_cast <CButtonControl *> (pControl);

    // casting works fine here since we had passed pControl1
    if(pButton != NULL)
    {
        pButton->OnClick();
        // We can now safely call OnClick() of CButtonControl
    }
    else
    {
        cout << "dynamic_cast failed. pControl is not pointing to instance of CButtonControl"<<endl;
    }
}

We need to note here that whenever dynamic cast fails with pointers it returns NULL. This is the reason why we are checking for

pButton!=NULL

Lets try dynamic casting with references,

void ProcessButtonEvent(CControlIface &Control)
{
    // Here we need make sure safe down-cast happens
    try{
    CButtonControl &Button = dynamic_cast <CButtonControl &> (Control);
    Button.OnClick();
    }
    catch(bad_cast)
    {
        cout << "Caught: bad_cast exception. This control is not a button"<<endl;
        return;
    }
}

In case of references if dynamic_cast fails, it throws bad_cast exception. This is the reason why we are catching the exception in the above code sample.

Please note that some old compilers may not support dynamic_cast. In that case its high time for you to upgrade your C++ compiler!

Global vs Member overloaded operator new

2007-09-04T21:41:00.002+05:30

In an earlier post we saw how to overload operator new, which will allow us to have customized memory allocation for an object on heap.

Its possible to place this overloaded operator new function either globally or as member function within a class.

// Global overloaded operator new
void *operator new(size_t size)
{
    return malloc(size);
}

// Class CTest
class CTest
{
public:
    // Member overloaded operator new
    void *operator new(size_t size)
    {
        return malloc(size);
    }
};

Is there any behavioral difference between these two versions of operator new?

Yes, there is.

If we have overloaded new as a member function within a class, it will always have high precedence over the globally defined version.

If we have a globally defined operator new function, the same will be used for all classes which doesn't have overloaded operator new defined within.

If both exist, the member version will be preferred over the global version.

Is there any advantage of this feature?

Yes.

Global version of overloaded operator new will be very much useful when we need to have a common strategy for memory allocation for all the classes in the module.

If we are in a situation where we need to have a specific way for allocation for a particular class which is different from others then we can overload operator new for the class with desired allocation method. A good example would be to allocate and initialize the allocated memory with zeros.

Zombie

2007-08-15T12:41:00.002+05:30

This article talks about handling a failing constructor.

What does it mean when I say Failing Constructor?

Consider a situation where we have written a constructor for a class and for some reasons it fails before fully executing the constructor. Constructor wont return any value, so it wont be possible for us to tell whether the constructor is fully executed or not.

What's the state of the object in this case?

Its a zombie object, because of the reason that the construction of the object has not happened in the expected way.

What's the problem with zombie objects?

Constructor has not executed completely, it has ended unexpectedly. This means the object has not been constructed. Hence, Destructor for the same object wont be executed. We will encounter problem, If we have done any dynamic allocations or opened any resource handles in the constructor before it fails, because the memory allocated wont be freed since the code for freeing up the memory or closing the resource handles usually sits in the destructor.

Code below explains this situation,

class CTest
{
public:
    // Constructor
    CTest();
    // Destructor
    ~CTest();
private:
    // Member pointer variables
    char *m_ptr1;
    char *m_ptr2;
};
// Constructor definition
CTest::CTest()
{
    // Init member pointers
    m_ptr1 = m_ptr2 = NULL;
    m_ptr1 = new char[100]; // Assume this succeeds
    m_ptr2 = new char[100]; // Assume this fails here!
    // Other processing

    ...
}

// Destructor definition
CTest::~CTest()
{
    delete [] m_ptr1;
    delete [] m_ptr2;
}

Have a look at the constructor CTest::CTest(), assume the first dynamic allocation succeeded for m_ptr1 and m_ptr2 failed for some reasons. Since the object is not constructed fully destructor wont be called and hence the heap allocations are not freed.

How do we overcome this problem?

One solution would be to catch the exception, free the allocated memory and then re throw the exception. Following code will show this technic.

// Constructor definition
CTest::CTest()
{
    // Init member pointers
    m_ptr1 = m_ptr2 = NULL;
    // try block
    try
    {
        m_ptr1 = new char[100]; // Assume this succeeds
        m_ptr2 = new char[100]; // Assume this fails here!
        // Other processing

        ...
    }
    // catch block
    catch(...)
    {
        // free the resources
        delete [] m_ptr1;
        delete [] m_ptr2;

        // re-throw
        throw;
    }
}

Another solution would be to use smart pointers, instead of just the raw pointers. When exception is thrown, the destructors for the local variables will be called as part of stack-unwinding which calls the destructor of the smart pointer which in turn frees the resources.

Enjoy C++!

Overloading "new"

2007-08-08T21:56:00.002+05:30

In one of the previous article about operator new, we saw that it can always be overloaded.

operator new can be overloaded to define its own way of allocating memory for an object. User should be able to control the way how it allocates the memory for the object.

The global new operator is the one which invokes a call to appropriate version of operator new if its overloaded and then it will call the constructor to complete the object instantiation process.

Below is the pseudo code of what new operator does

new()
{
    // Call correct version of operator new() based on the parameters passed while initializing the object
    operator new(sizeof(CMyClass));
    // Call appropriate version of constructor
    CMyClass::CMyClass();
}

Function operator new always has size_t as one of its parameter. The functionality of a default operator new will be as shown below,

void* operator new(size_t size)
{
// allocate and return the pointer
return malloc(size);
}

Where it allocates size number of bytes and return the pointer which points to the allocated memory.

If user tries to instantiate an object of type CMyClass dynamically,

CMyClass *pObj = new CMyClass();

This will call the global new operator() function which will first call operator new(sizeof(CMyClass)) passing sizeof(CMyClass) as parameter to allocate required memory, then it will call the constructor CMyClass::CMyClass() to finish the object instantiation process.

In some cases user may want to allocate memory for an object in a predefined memory area. This can be achieved by overloading operator new().

void* operator new(size_t size, void *pMem)
{
// just return the pre allocated memory pointer
return pMem;
}

User can invoke this by doing the following,

char *buf = new char[500]; //pre-allocated buffer
CMyClass *pObj = new (buf) CMyClass(); //placement new

This will invoke the overloaded version of function operator new() which takes two parameters, first would be the size of the class and the next would be the pointer to pre-allocated buffer.

operator new(sizeof(CMyClass), buff);

And this overloaded version will just return the pointer to new operator() function which will then call the appropriate constructor.

This technic is popularly known as Placement New.

In the same way user should be able to overload operator new with different parameters.

Cheers!

Overloading const and non-const member functions

2007-08-03T09:53:00.002+05:30

We all know about the function overloading feature in C++. Where we can have the same name given for a function with different signatures. Different signature here means different types or number of arguments for that function.

How about overloading based on constness of a member function?

Consider the scenario below,

class MyArray
{
private:
    int m_iInts[100]; // Array of integers
public:
    int& operator [](int iIndex); // Overloading subscript operator
};
int& MyArray::operator[](int iIndex) // Definition
{
    return m_iInts[iIndex];
}

We are trying to create an integer array class, with an overloaded operator function for subscript access of the array.

we should be able to say

MyArray objArray;
objArray[10] = 100;

This will establish a call to the member function operator[](int), which returns a reference to the requested array member. It will assign a value to that particular array member.

But, consider the situation below,

void PrintArray(const MyArray &obj)
{
// Code for printing the elements
cout<<obj[10]<<endl;
}

Assume that this is a function for printing the array elements. This takes a constant reference to MyArray instance as parameter.

Problem is here!

When we try to print the value by saying obj[10], since the object is of constant type, it will not be able to access the non-const version of operator[](int).

Compiler complains about this saying

no operator defined which takes a left-hand operand of type 'const class MyArray'

In this situation we must declare another version of operator[](int) which will be specifically for const objects.

const int MyArray::operator[](int index) const
{
return m_iElements[index];
}

This is a const member function - meaning not supposed to change value of any member variable.

Hence we have 2 versions of member functions with same name and even same argument but different in constness.

int& operator [](int iIndex); // non-const version
const int operator[](int index) const; // const version

The first version will be used for all non-const objects and the later will be only used for const objects.

Happy coding!

Accessing non-static member function without object!

2007-08-01T01:19:00.002+05:30

We know that we can call a static member function with in a class without instantiating that class. But how about a non-static member function?

Its possible too, unless we try to access any of the member variable within that function.

class CTest
{
public:
    void func()
    {
        cout<<"I can execute even without an object!"<<endl;
    }
};
int main()
{
    CTest *p = 0; // NULL pointer
    p->func();     // Calling member function
    return 0;
}

This compiles and works fine.

But beware! We must not try to access any of the member variables within that because this pointer will be pointing to NULL.

Remember there was an article about how a member function call is made?

Cheers!

How to pronounce Bjarne Stroustrup?

2007-07-30T11:10:00.001+05:30

Here is an audio-link in which Bjarne himself tells how to pronounce his name.

RTTI

2007-07-28T22:24:00.002+05:30

Run Time Type Information (RTTI) is the concept which facilitates us to identify type of a polymorphic object at run time (typeid operator) and to perform type-safe down casting. There is an article already in this blog about type-safe down-casting - dynamic_cast.

typeid is an operator which can be used to find out the dynamic type of a polymorphic object. It can be used to identify the type of the object referenced by or pointed at run time.

When do we need to use it?

Ideally never. If we design the system properly we shouldn't be using this operator. But in certain cases where we cannot avoid, we may have to use typeid operator.

Let's look at an example.

class CShape
{
    ...
};
class CCircle : public CShape
{
    ...
};
class CRectangle : public CShape
{
    ...
};
void Draw(CShape *pShape)
{
    if(typeid(*pShape) == typeid(CCircle))
    {
        cout<<"Circle"<<endl;
    }
    else if(typeid(*pShape) == typeid(CSquare))
    {
        cout<<"Circle"<<endl;
    }
}
int main()
{
    CCircle *circle = new CCircle();
    CSquare *square = new CSquare();
    Draw(circle);
    Draw(square);
}

This prints "Circle" and "Rectangle".

In function Draw(), typeid is returning the polymorphic type of the object pointed by pShape which is unknown at compilation type.

typeid uses RTTI to find out the class type at run time.

Don't ever mix Arrays with auto_ptr !

2007-07-14T11:58:00.002+05:30

This article is in response to one of the comments for my previous article about auto_ptr.

auto_ptr which is provided by the standard C++ library wont work with arrays. It's best to avoid using auto_ptr for arrays.

What is the problem?

To understand the problem, let's take a loot at C++'s memory management background. We all know that, any "new" statement we use for dynamically creating object should be accompanied with a call to "delete" for deleting that object.

CMyClass *p = new CMyClass; //Dynamically create an object
// some other processing
...
delete p; // delete the object

Also, if we are allocating an array of objects using new[], that must be freed using delete[] operator, which frees up all the dynamically allocated objects.

CMyClass *p = new CMyClass[5]; //Dynamically create array of objects
// some other processing
...
delete[] p; // delete the objects

In case of auto_ptr, the destructor will just do a delete on the embedded pointer member variable.

auto_ptr::~auto_ptr() // Destructor
{
delete ptr; // free the memory
}

There's no way for auto_ptr to intelligently do delete or delete[] based on the scalar or vector dynamic objects pointed by the member pointer.

If we do

auto_ptr<int> obj(new int[10]);

When obj goes out of scope, the destructor will be called and only delete will be done on the pointer. Which ideally had to be delete []. This causes leak and may cause undefined behavior.

Its always recommended to avoid using auto_ptr with arrays.

There are few solutions proposed for this problem by Herb Sutter here.

C++0x

2007-07-08T15:04:00.002+05:30

The next version of C++!

Bjarne offers a sneak peek at the next version of standard C++ ("C++0x") which should be complete by 2009.

C++0x

Smart Pointers

2007-07-08T14:43:00.002+05:30

"Smart Pointers" Why do we need it?

It behaves like a pointer but does more than that. If used properly, it can enhance the code robustness, reduce memory leak headaches.

What more does it do?

Consider a scenario, where we use dynamic memory allocations extensively. We need to keep track of each allocation we did, for freeing it back to the system after its usage. if we forget, sure there will be a leak.

void SomeFunction()
{
    CSomeClass *ptr = new CSomeClass();
    ...
    ptr->MemberFunction();
    ...
    return; // Usual mistake! forgot to free memory. Leak!
}

Consider another case, where we allocated memory dynamically but the statement next to that thrown an exception. It contributes for a memory leak, unless the exception is caught and the memory is freed.

void SomeFunction()
{
    CSomeClass *ptr = new CSomeClass();
    ...
    ptr->MemberFunction(); // If this function throws exception, memory pointed by ptr won't be freed unless this is caught and freed
    ...
}

One more case for analysis,

CSomeClass* ptr = new CSomeClass();
CSomeClass* otherptr = ptr;
...
ptr->SomeFunction();
...
delete ptr;
ptr = NULL; // ptr - used and safely deleted
...
otherptr->SomeFunction(); // Dangerous! otherptr is dangling

All these can happen with developers' small negligence. Using Smart pointer can avoid such nasty situations.

How?

Let's have a look at auto_ptr.

auto_ptr is one of the smart pointer templated class in Standard C++ library. It encapsulate a pointer. To embed any primitive or user defined pointer type, it has been made a templated class.

template<class T>
    class auto_ptr
    {
public:
    auto_ptr(T *p = 0);    // Constructor
    auto_ptr(const auto_ptr<T>& Y); // Copy constructor
    ~auto_ptr()    // Destructor
    {
        delete ptr; // free the memory
    }
    ...
private:
    T *ptr;
    };

On executing the constructor of this, it takes the ownership of the memory pointed by the pointer. Since the instance of the auto_ptr is crated on stack, the developer need not worry about freeing the memory.

void function()
{
    auto_ptr<CSomeClass> smartPtr(new CSomeClass());
    // Use smartPtr

    ...
    // No need to worry about freeing the memory
    // When the SmartPtr goes out of scope, will call the auto_ptr's destructor which will in turn delete the embedded ptr
}

Even if there is an exception thrown before cleaning up, stack-unwinding will initiate the auto_ptr's destructor which will in turn free the memory.

Next question is how will we be able to use the smart pointer as a pointer. I mean we should be able to do the following things normally as we were doing with mere pointers,

smartPtr->SomeFunction();
*smartPtr = 3;

auto_ptr has few more overloaded functions, which facilitates us to achieve this.

T& operator*() const
{
return *ptr;
}
T *operator->() const
{
return ptr;
}

These two operator overloaded functions enable us to use smartPtr as regular pointer. operator *() will help in dereferencing the pointer and operator->() will do the indirection job.

Article about auto_ptr at gotw

Library - Reusable binary component

2007-06-30T14:44:00.001+05:30

In our daily development activities, we will come across various types of libraries. Like Static Library, Dynamic Linked Library, Plugins etc,

In this article, I have tried to explain each of these.

You consider any type of library, final objective will remain the same - Binary Reusability.

Developer should identify a set of re-usable components or routines in his module and create a library. So that, this can be distributed and used by anyone instead of rewriting the components again.

Lets start from Static Library(.lib) (called as Archive in unix world). Usually libraries will be create with .lib extension (.a in unix). The idea behind static library is to create a reusable binary module that can be linked with any executable or another dynamic library, so that it can reuse the static library components. Linking/Binding module will have the responsibility of linking your executable with the static library. Hence the final size of the executable will be original executable code size + the static library code size. The executable will embed the static library within.

All the routines and components which were present in the static library can be directly used as if they were implemented in the same module.

After compilation, at link time the linker module will look for all the symbols which were referenced in the executable and tries to link the static library. The developer has to specify the static library so that the linker can link it with the executable.

Dynamically Linked Library (DLL): Generally we export functions or routines from DLLs. When we say export that means those are all the entry points for the executables that are linked with it. Only the exported functions can be accessed by the executables.

We can use the DLLs in two ways. One way is to link the static interface of a DLL with an executable and another is to load the DLL at run-time. Both have its own advantages.

Statically linking the DLL interface : For any DLL, there will always be a static library(.lib) generated. This static library is just an interface to the DLLs exported functions, they wont have any definitions for the exported functions. They are just like routers to the actual definition which is present in the DLL.

Executables can link to this static library and use the exported functions in the DLL. The executable will just have DLLs interface embedded in it. DLL will be a separate module which will be loaded by the loader when we start the executable.

In this method, the DLL will be loaded when we start the executable. The life span of the exe along with the DLL can be depicted as below,

Loading a DLL at Run-time : This is the second way of using a DLL. Where we can use certain System API's to load the DLL at run-time. The static interface for the DLL is not used in this case. A typical example is shown below.

// Load the library
MyDll = LoadLibrary("C:\\MyWork\\aDll.dll");
// Get address of exported function
FuncPointer = GetProcAddress(MyDll, "SomeExportedFunc");
// Make call
FuncPointer();
// Release the library
FreeLibrary(MyDll)

Note here that, the DLL can be loaded and released at any point of time with in the life span of the exe. Which is different from the previous method where it would load it at the start of the execution itself.

A Plugin is an extension to this method. Lets talk about this in further articles.

Cheers!

Can access a private function?

2007-06-29T22:02:00.002+05:30

Today, at lunch time, Anand had a slip in his hand with C++ code written on it. He was smiling showing that to me and asking to tell how the code behaves.

As usual he had a great feeling of discovering some new thing ;)

I had to watch the code, it goes like below

Class CBase
{
    public:
        virtual void vfunc()
        {
            // Some definition
        }
};

Class CDerived : public CBase
{
    private:
        void vfunc()
        {
            // Some definition
        }
};

int main()
{
    CBase *pBase = new CDerived();
    pBase->vfunc();
}

CBase has a virtual function vfunc which is overridden in CDerived. In the main routine we are making a base pointer to point to the derived class instance. Then we are calling the vfunc.

The main point to note here is - CDerived::vfunc() is private.

Even the function is declared as private its accessible! when we do

pBase->vfunc();

Strange!

This is because the real call to the function is made thru virtual pointer.

We wouldn't be able to access the same function via an instance of CDerived. Isn't it?

What to say about this? Is this a design flaw? A loop hole? or just say "This is what C++ is"!

dynamic_cast

2007-06-24T18:39:00.002+05:30

Lets talk about Dynamic Casting today!

dynamic_cast is one of the four C++ casting operators (static_cast, dynamic_cast, reinterpret_cast and const_cast), extensively used in case of polymorphic types.

Unlike C type casting which does a static type check, this will do a type check at run time. If the casting is invalid, it either throws bad_cast exception or returns a NULL pointer.

This has to be used for safe run-time down casting.

What is Down casting?

Casting a superclass pointer (or reference) into a pointer (or reference) to a subclass in a class hierarchy is said to be down casting.

Typical example looks like this,

CDerived *pD = dynamic_cast<CDerived *>pB;

When to use?

Consider the scenario below,

Where the CControlIface is an abstract base class with a pure virtual function Draw(). There are two concrete classes implementing the CControlIface interface, CButtonControl and CTextControl which overrides the Draw()'s implementation. Also, they have their own methods

CButtonControl::OnClick()
CTextControl::OnKeyTyped()

The problem is how will we identify the type of object pointed at run-time, if we just have the base class pointer or reference?

The solution is dynamic_casting

Let's look into some code.

CControlIface *pControl1 = new CButtonControl();
CControlIface *pControl2 = new CTextControl();
...
...
ProcessButtonEvent(pControl1);
// No idea what pControl1 points to, at compile time
...
...
void ProcessButtonEvent(CControlIface *pControl)
{
    // Here we need make sure safe down-cast happens
    CButtonControl *pButton = dynamic_cast <CButtonControl *> pControl;
    // casting works fine here since we had passed pControl1
    ...
    if(pButton != NULL)
    {
        pButton->OnClick();
        // We can now safely call OnClick() of CButtonControl
    }
}

What would have happened if we had passed pControl2 while calling ProcessButtonEvent()?

dynamic_cast would have failed since pControl2 is not pointing to CButtonControl's instance. This check is performed by dynamic_cast operator at run-time using RTTI (Run-time Type Information).

Dynamic casting allows us to perform safe type conversions and lets our programs take appropriate actions when such casts fail.

Cheers!

What's "new"?

2007-06-17T16:48:00.001+05:30

Today's article talks about the new, which is an essential operator in C++ for dynamically instantiating an object.

Why do we need new operator?
There's a lot of difference between C's malloc and new. It does more than just allocating memory. It also calls the constructor. Which facilitates to initiate the object.

Believe me, operator new and new operator are completely different!
When we instantiate an object
CTest *pObj = new CTest();

This calls global new operator which performs 2 main tasks
1. Call operator new for allocating memory.
2. Call constructor of the particular object.

We can always overload operator new which performs memory allocation operations. But we cannot change the meaning of the global new operator.

Typical example where we overload operator new will be in case of placement new where we change the actual meaning of operator new by passing address of memory where it has to instantiate the object.

Let's talk about placement new in forth coming articles.

Conceptual "Virtual Constructors"

2007-06-12T17:56:00.001+05:30

In one of my old article I had said that we cannot make the constructors virtual.

But its possible to have Conceptual Conceptual "Virtual Constructors". You might be wondering what do I mean by conceptual here?

Consider following code snippet,

class CAccountIface
{
};
class CSavingsAccount : public CAccountIface
{
};
class CCreditAccount : public CAccountIface
{
};

And I have one more class which will have a list of accounts

class CBank
{
    public:
        CAccountIface* CreateAccount(int iAccType);
        std::vector<CAccountIface *> m_Accounts;
}

Here the member function CAccountIface* CBank:: CreateAccount(int iAccType) acts like a virtual constructor. Depending on the type the user passes either the constructor for CSavingsAccount or CCreditAccount will be called and respective object will be instantiated. This behaves like a virtual constructor.

We can even establish virtualism in case of copy constructors.

Let's try writing a copy c'tor for CBank class.

CBank::CBank(const CBank &AnotherBank)
{
    for(std::vector<CAccountIface *>::size_type i = 0; i < AnotherBank.m_Accounts.size(); ++i )
    {
        this->m_Accounts[i] = AnotherBank.m_Accounts[i]->Clone();
    }
}

I guess u'll already be wondering about the implementation for clone() member function.

Clone() has to be a pure virtual function in CAccountIface, and we can override this in CSavingsAccount and CCreditAccount to clone itself.

So the updated code will be as shown below,

class CAccountIface
{
    public:
        virtual CAccountIface *Clone() = 0;
};
class CSavingsAccount : public CAccountIface
{
    public:
        virtual CSavingsAccount *Clone(){ return new CSavingsAccount(*this);}
};
class CCreditAccount : public CAccountIface
{
    public:
        virtual CCreditAccount *Clone(){ return new CCreditAccount(*this);}
};

When we say

m_Accounts[i]->Clone();

The Clone() function will be called based on the type of object pointed by the pointer m_Accounts[i].

This concept is also referred to as "Factory Pattern"

Static & Dynamic memory allocations...

2007-06-02T11:45:00.001+05:30

I thought of writing this article since it was quite interesting even though it sounds as basic and primitive.

Last night when I was coming back to home on Company's shuttle, my mate Debendra had few C++ questions for me.

He asked "If I create a variable on stack say, int i; and if I say char *p = new char;. When will be the memory gets allocated? What time? Is it run-time or compilation time?"

I had to say "All allocations happen only when you run the program, compiler will just compile the C++ code to instructions which will allocate the memory required on heap/stack"

Then I got an unexpected question from him - "Then why do we say int i; as static allocation and char * p = new char as dynamic allocation, even though all allocations are happening at run-time?"

A crazy question!

Such a primitive and basic doubt every one may get and get confused.

All allocations whether it may be dynamic or static happens at run-time only. But how the allocation is done matters.

Let’s take the static allocation,

int i;

when compiler compiles this code, compiler knows what the size of int is and it knows what number of bytes needs to be allocate at compilation time only. It generates instructions to allocate those many bytes, so that at run-time those many bytes are allocated.

In case of dynamic allocation,

char *p = new char(n);

Compiler wont have any idea what is n, it may be a function parameter or a value evaluated by an expression or even it can be a constant value, but at compilation time it has no idea what may be the number of bytes allocated. This can be dynamically configured and controlled at run-time.

Importantly, in case of dynamic allocation, the amount of memory allocated is determined by the program at the time of allocation and need not be known in advance.

Hence we say this as dynamic allocation.

Hope Debendra had got his doubt cleared.

Const Correctness

2007-05-31T09:24:00.000+05:30

I recently found a good article by Herb Sutter on Const-Correctness, a powerful feature of C++. This article talks about when to use const and when not to use it.

Const Correctness by Herb Sutter

Very interesting!

Resolving function address ...

2007-05-24T21:48:00.000+05:30

The question is, if we are calling a function 'void function()' from 'main()', how the call is actually made?

We know the answer, it will be just a jump instruction to a particular address where the function instruction set starts.

How the member function address resolved in C++?

We all know member function is not stored as part of the class. It will be stored outside somewhere (code segment?). Then how is the call made when we say 'obj.function()'?

The answer is simple, actual call made would be like 'function(&obj)'. Thereby it will be just a simple jump instruction as we saw earlier.

Calling ctor!!

2007-03-14T17:05:00.001+05:30

Well, suppose we have a class as below

class CTest
{
    public:
        CTest()
        {
            cout<<"ctor called!";
        }
};
int main()
{
    CTest();
}

Does it mean c'tor can be called without creating an object?

Nope!! ofcourse not!!

The reason is when CTest(); is called, the compiler inserts the code to create a tempory object of CTest and calls its c'tor. Also it destroys the object right after executing CTest(); statement.

That is the reason calling constructor inside another constructor is not valid.

delete this;

2007-01-16T23:36:00.000+05:30

"delete this;" legal?

Yes! of course its legal, with certain restrictions.

Once you call 'delete this;' no member variables should be accessed, since they would have been deleted already.

class CTest
{
    int iInt;
    char *iStr;
    public:
        void func()
        {
            ...
            delete this; // object destroyed here
            ...
            iInt = 6;// Illegal! don't do this
        }
};

Also this is not valid if the object is created on stack. Following should not be done.

CTest obj;
obj.func(); // Not valid since obj is on stack

CTest *ptr = new CTest();
ptr->func();

// Valid, only if no members are accessed after delete this;

One more interesting fact! What if we use 'delete this;' in destructor? ;)
Of course it will create the recursion calls to destructor!!!

Is there any practical use of this then?

Yes!

Consider the scenario where I would want to restrict the user to be able to create an object only on heap. User should not be able to create the object on stack.

We can achieve this by making destructor private. There by preventing the stack unwinding to happen, which will intern avoid creating variables on stack. Then the user will only be able to create object on heap.

class COnlyOnHeap
{
private:
~COnlyOnHeap(); // destructor made private
};
COnlyOnHeap obj; // Not possible since d'tor is private.
COnlyOnHeap *ptr= new COnlyOnHeap(); // Possible

We achieved our goal!

Object can only be created on heap but not on stack.

But, Wait!

How will u cleanup this?

We cannot say "delete ptr", because d'tor is private.

How will we cleanup this then?

The only way is to expose one more cleanup public function which does "delete this;"!

COnlyOnHeap::Cleanup()
{
delete this; // This calls the private d'tor within the class
}

Enjoy C++

Implementing a "final" class in C++

2007-01-16T22:07:00.001+05:30

The key word "final" exists in java world. It means, no class can inherit from the class declared as "final". A class which cannot be inherited further.

The simple method by which we can achieve this is to make the constructor of the class private.

class CFinal
{
    private:
        CFinal(); // Private constructor to avoid inheritance
    public:
        static CFinal *GetInstance();

       // static public member function to create the instance
};

This method looks very simple. If we try to derive another class from CFinal and try to instantiate that class, compiler errors out saying cant access CFinal's constructor, since its private.

But, this method has its own drawbacks,

Need to have a static public member function to create instance.

If the class needs to have more than one type of c'tors, all these c'tors need to be replaced by corresponding version of static-public-member function.

Object cannot be instantiated on stack.

What if we make destructor private, instead of c'tors?
We can achieve the "final" thing.
But, this too cannot be instantiated on stack (stack-unwinding needs d'tors to be public).

We can club private d'tors, private c'tors, friend-class and virtual inheritance concepts to achieve a good solution.

class CFinal; // Forward declaration
class CFinalLocker
{
    private:
        CFinalLocker();
        ~CFinalLocker();
    friend class CFinal;
};
class CFinal : public virtual CFinalLocker
{
    ...
};
class CDerived : public CFinal
{
    ...
}
CFinal objFinal; //OK - no problem
CDerived objDer; // Error! - Cant access CFinalLocker's c'tor

Following is the useful explanation of the above technique

CFinalLocker which is the base class for CFinal will have all of its c’tors and the destructor private.

CFinal has been made friend of CFinalLocker. This is to facilitate CFinal to access all the members of CFinalLocker including members which are private. This will allow us to instantiate CFinal.

We inherit our CFinal virtually from CFinalLocker. Now whenever anyone attempts to inherit class from CFinal and try to instantiate it, then its constructor tries to call the constructor of CFinalLocker. But the constructor of Temp is private so compiler complains about this and it gives error during the compilation, because your derived class is not friend of CFinalLocker. Remember friendship is not inherited in the derived class.

The purpose of inheriting CFinal virtually from CFinalLocker : the object of most derived class (whose object is created) directly calls the constructor of virtual base class (to avoid diamond problem). Now the most derived class (Bottom in case of diamond problem) directly calls the most base class (Top in diamond problem) constructor. So when we try instantiating CDerived compiler errors out since the c’tor in CFinalLocker is private.

When do we need to have definition for a "Pure Virtual Function"?

2007-01-12T11:06:00.000+05:30

Any answers?

Why can't we have "Virtual Constructors"?

2007-01-11T23:01:00.000+05:30

Virtual mechanism acts on 'complete objects'.
An object is complete 'after' the constructor has finished executing.
So, it is illegal to make constructors virtual.
Destructors can be virtual because by the time you apply them object has been constructed completely.

Need for "Virtual Destructor"

2007-01-11T22:56:00.000+05:30

If we have 2 classes, say

class CBase{
public:
CBase(){}
~CBase(){}
};

class CDerived : public CBase{
public:
CDerived(){}
~CDerived(){}
};

and if we do,

CBase* pBase = new CDerived;
delete pBase;

Since CBase does not have a virtual destructor, the delete pBase invokes the destructor of the class of the pointer (CBase::~CBase()), rather than the destructor of the most derived type (CDerived::~CDerived()). And as you can see, this is the wrong thing to do in the above scenario.

A class must have a virtual destructor if it meets both of the following criteria:

You do a delete pBase.
pBase actually points to a derived class object.

Assignment operator Vs. Copy constructor

2007-01-11T21:58:00.000+05:30

The copy constructor is for creating a new object. It copies a existing object to a newly constructed object.

The assignment operator is to deal with an already existing object.

class MyObject
{
    public:
        MyObject(); // Default constructor
        MyObject(MyObject const & a); // Copy constructor
        // Assignment operator
        MyObject & operator = (MyObject const & a)
};

The copy constructors play an important role, as they are called when class objects are passed by value, returned by value, or thrown as an exception.

// A function declaration with an argument of type MyObject,
// passed by value, and returning a MyObject
MyObject f(MyObject x)
{
    MyObject r;
    ...
    return(r); // Copy constructor is called here
}
// Calling the function :
MyObject a;
f(a); // Copy constructor called for "a"

It should be noted that the C++ syntax is ambiguous for the assignment operator.

MyObject x; x=y;

and

MyObject x=y;

have different meaning.

MyObject a; // default constructor call
MyObject b(a); // copy constructor call
MyObject bb = a; // identical to bb(a) : copy constructor call
MyObject c; // default constructor call
c = a; // assignment operator call

Overloading Vs. Overriding

2007-01-11T21:50:00.000+05:30

Overloading is nothing but static binding.

Overriding is dynamic binding which will be resolved at run-time.

Overloading deals with multiple methods in the same class with the same name but different signatures.

Overriding deals with two methods, one in a parent class and one in a child class, that have the same signature.

Overloading lets you define a similar operation in different ways for different data.

Overriding lets you define a similar operation in different ways for different object types.