I just realized that the macro also fails to work with anonymous types under certain circumstances.  To be exact, If you call countof() on two arrays that have different anonymous types AND same size, then the second call will fail to compile.

e.g.

The reason is that in this case, the second instantiation of the template helper function _ArraySizeHelper clashes with the first instantiation.

Note that if you change the size of g_b to something other than 100, it compiles fine.

So the caveat should be “countof() does not work with local types, and under certain circumstances does not work with anonymous types.”

I cannot believe it’s so difficult to get such a simple job (getting the number of array elements) done in C++.

What a broken language it is.

Ask not what you can do in XSLT; ask what you cannot do in XSLT. :-)

(For those of you concerned that you need to buy an XSLT compiler to try it out, take heart -- all you need is your web browser)

The most well known implementation of smart pointers probably is auto_ptr in STL and CAutoPtr in ATL, which will delete the object upon destruction.

auto_ptr and CAutoPtr are fine, but they have limitations:

1. Sometimes the pointer is not allocated via the new operator (e.g. malloc()).  In these cases, you don’t want to use auto_ptr or CAutoPtr as the pointer will by wrongfully deleted (as opposed to be free()-ed in the case of malloc()).
2. They are good for wrapping pointers only.  In general, you would like to allocate some resource and have the compiler release it for you automatically.

Why not generalize smart pointers to smart resource managers?  It’s actually easy to do so.  Here’s my take on this:

To use the CAutoResource template class, you need to supply:

1. The type of the resource;
2. A function that disposes of the resource; and
3. (Optional) The value that represents the “null” resource.  If you don’t specify it, 0 is used.

Upon destruction, the resource in a CAutoResource object will be released by calling the resource disposition function.

I hope it becomes obvious to you that auto_ptr and CAutoPtr are basically special cases of CAutoResource where the disposition function is the delete operator.  They do have more member functions, but those are not hard to add.

Let’s see some examples of using CAutoResource.

The first one is to wrap the generic Windows HANDLE, which is used by the Win32 API to represent a lot of different things (windows, fonts, brushes, memory, and etc).  A typedef instantiates CAutoResource for this scenario:

Our second example is handle to a registry key:

Sometimes, two resources have the same C++ type but different semantics and should be released in different manners.  For example, an HINTERNET should be released by either WinHttpCloseHandle() or InternetCloseHandle(), depending on whether it was allocated using the WinHttp or the WinINet API.  This is no problem for us, as the disposition function is a type parameter to CAutoResource and you can specify different functions for the same C++ type:

Let’s give one example where the resource we want to manage is a pointer:

So far so good, but as soon as you try to dereference a pointer masqueraded as a CAutoResource, you’ll find we haven’t defined the dereference operator (*) and the arrow operator (->) yet.  This is because they don’t make sense in the context of general resources.

What we can do is to define these operators in a sub-class of CAutoResource.  I would’ve called it CAutoPtr, but that name is taken, so instead we have CAutoPtrEx:

I’ll finish this article with an example using CAutoPtrEx:

(This posting is provided "AS IS" with no warranties, and confers no rights.)

template <typename T>

class Array { … };

Then we can use the same template to generate code for different template parameters.  This is called instantiation of the template.  e.g.

Array<int> x;

Array<string> y;

However, sometimes we don't want to use the same definition for certain template parameters.  For example, the generic definition for Array<bool> might not be as efficient as we want.  We can write a specialized implementation for Array<bool> that uses only 1 bit for each element in the array.  Such is called specialization of the template.

C++ supports specialization by the following syntax:

template <>  // empty template parameter list!

class Array<bool> { … };

Here's the complete example.  In this program, we present a generic definition for a template class Array, then we present a specialized definition for the case when the template parameter is bool.

// This example shows how to supply a specialized implementation when

// instantiating C++ template class.

// This code is SIMPLIFIED for illustration purpose, and should NOT be used

// unmodified in production code!!!

// (c) Zhanyong Wan

// 3/17/2004

#include <iostream>

// The generic definition for the Array template class.

template <typename T>

class Array

{

private:

    T * elements;

    int size;

public:

    Array( int aSize )

        : size( aSize )

    {

        // size validity checking code omitted...

        elements = new T[ aSize ];

        // (elements != NULL) test omitted...

    }

    virtual ~Array()

    {

        delete[] elements;

    }

    void Set( int idx, const T& value )

    {

        // array-bound checking code omitted...

        elements[ idx ] = value;

    }

    T& Get( int idx ) const

    {

        // array-bound checking code omitted...

        return elements[ idx ];

    }

};

typedef unsigned char byte;

// An specialized implementation for Array< bool > that optimizes for space

// by representing a bool element with a single bit.

// In C++, a template with an empty parameter list is the syntax for

// specialization.  IMHO, keyword overloading is abused in C++.

template <>

class Array< bool >

{

private:

    byte * buffer;

    int    size;

    const static int BitsPerByte = 8;

public:

    Array( int aSize )

    {

        // size validity checking code omitted...

        buffer = new byte[ aSize/BitsPerByte + 1 ];

        // (buffer != NULL) test omitted...

    }

    virtual ~Array()

    {

        delete[] buffer;

    }

    // The specialized class is NOT obliged to have the same set of methods

    // as the generic class!

    void Set( int idx, bool value )

    // Note that we change the prototype of the Set() method here for better

    // performance.  As a result, it does not match the prototype of the

    // Set() method in the template Array class.  This is OK, as C++ doesn't

    // impose any relationship between a template class and its specialization.

    {

        // array-bound checking code omitted...

        const int  byteIdx = idx/BitsPerByte;

        const int  bitIdx  = idx - byteIdx*BitsPerByte;

        const byte bitMask = 1 << bitIdx;

        if ( value )

        {

            buffer[ byteIdx ] |= bitMask;

        }

        else

        {

            buffer[ byteIdx ] &= ~bitMask;

        }

    }

    bool Get( int idx ) const

    {

        // array-bound checking code omitted...

        const int  byteIdx = idx/BitsPerByte;

        const int  bitIdx  = idx - byteIdx*BitsPerByte;

        const byte bitMask = 1 << bitIdx;

        return ( buffer[ byteIdx ] & bitMask ) != 0;

    }

};

int main()

{

    const int size = 6;

    Array< int >  intArray ( size );

    Array< bool > boolArray( size );

    for ( int i = 0; i < size; i++ )

    {

        intArray.Set( i, i );

        boolArray.Set( i, (i % 2) == 1 );

    }

    for ( i = 0; i < size; i++ )

    {

        std::cout << intArray.Get( i )

             << "\t"

             << boolArray.Get( i )

             << "\r\n";

    }

    return 0;

}

I can think of three reasons why this is happening:

1. The C++ syntax sucks;
2. I'm getting old; and
3. The existing documentation sucks.

While I cannot do much about the first two, I figure at least I can work on the third.  The result is this quick reference.  It has helped me in a number of situations.  It might help you as well, if you are getting old too!

You use a member function pointer because eventually you want to invoke it.  Before you can do that, you also need to declare the type of the pointer, define a variable of that type, and assign a value to that variable.  This reference teaches you how to do each of them.

• Declaring a member function pointer type

Suppose you want to point to a non-static member function of a class CMyClass, where the argument has type Arg and the result type is Res.  You can declare the type of your pointer by

typedef Res (CMyClass::*MemFunc)( Arg );

(Note the highlighted parentheses cannot be omitted).

Then you can declare your member function pointer pMemFunc as having type MemFunc:

MemFunc pMemFunc;

• Obtaining a value of your member function pointer type

The next step, you need to give a value to your pointer.  Suppose the CMyClass class looks like:

class CMyClass

{

...

Res MyMethod( Arg arg );

...

};

You can let pMemFunc points to the function MyMethod by:

pMemFunc = &CMyClass::MyMethod;

Alternatively, you can do without the ampersand, which is my preferred way:

pMemFunc = CMyClass::MyMethod;

• Invoking a member function via a member function pointer

Now that your pointer has a value, it's time to put it to use!  Since pMemFunc points to a member function, you need to have an object to begin with.  Suppose the object is called MyObj:

CMyClass MyObj;

You can invoke the function pointed to by pMemFunc on MyObj like this:

Res result = (MyObj.*pMemFunc)( arg );

Note that the highlighted parentheses cannot be omitted.

However, none of the following syntaxes is accepted:

Res result = MyObj.(*pMemFunc)( arg );

// Won't compile

Res result = MyObj.*pMemFunc( arg );

// Won't compile either

Res result = MyObj.pMemFunc( arg );

// You wish!

This is different from how C++ treats member functions (you can write either (MyObj.MyMethod)( arg ) or MyObj.MyMethod( arg )), and different from how it treats ordinary (non-member) function pointers too (given a function pointer pFunc, you can invoke it with either (*pFunc)( arg ) or pFunc( arg )).

In an ideal language, all constructs should be equal (to be precise, I mean "orthogonal").  Now C++ is telling me that member function pointers are less equal than others.  This bothers me.  This bothers me tremendously.

Maybe C++ has become old?

P.S. Someone who calls himself “Daniel” made the following comment:

Bjarne Stroustrup said, "I consider the C declarator syntax an experiment that failed." But we're stuck with it. If you read 'The Design and Evolution of C++' a much nicer syntax is suggested.  Sort of reminiscent of Pascal I think.

I haven't got a reference to hand, but I think you need the brackets for calling member functions because otherwise it could mean that you were calling a function which return a pointer to a member variable. ie. MyObj.*pMemFunc( arg ) is equivalent to MyObj.*(pMemFunc( arg )). Here's some code to illustrate:

#include <iostream>

struct my_object
{
    int x;
};

int my_object::* function()
{
    return &my_object::x;
}

int main()
{
    my_object x = {1};
    x.*function() = 3;
    std::cout<<x.x<<'\n'; // Prints 3.
}

An obvious solution is the following macro (definition 1):

I cannot say this isn’t correct, because it does give the right answer when you give it an array.  However, the same expression gives you something bogus when you supply something that is not an array.  For example, if you have

          int * p;

then countof( p ) always give you 1 on a machine where an int pointer and an int have the same size (e.g. on a Win32 platform).

This macro also wrongfully accepts any object of a class that has a member function operator[].  For example, suppose you write

then sizeof( x ) will be the size of the x object, not the size of the buffer pointed to by x.p.  Therefore you won’t get a correct answer by countof( x ).

So we conclude that definition 1 is not good because the compiler does not prevent you from misusing it.  It fails to enforce that only an array can be passed in.

What is a better option?

Well, if we want the compiler to ensure that the parameter to countof is always an array, we have to find a context where only an array is allowed.  The same context should reject any non-array expression.

Some beginners may try this (definition 2):

They figure, this template function will accept an array of N elements and return N.

Unfortunately, this doesn’t compile because C++ treats an array parameter the same as a pointer parameter, i.e. the above definition is equivalent to:

It now becomes obvious that the function body has no way of knowing what N is.

However, if a function expects an array reference, then the compiler does make sure that the size of the actual parameter matches the declaration.  This means we can make definition 2 work with a minor modification (definition 3):

This countof works very well and you cannot fool it by giving it a pointer.  However, it is a function, not a macro.  This means you cannot use it where a compile time constant is expected.  In particular, you cannot write something like:

Can we do anything about it?

Someone (I don’t know who it is – I just saw it in a piece of code from an unknown author) came up with a clever idea: moving N from the body of the function to the return type (e.g. make the function return an array of N elements), then we can get the value of N without actually calling the function.

To be precise, we have to make the function return an array reference, as C++ does not allow you to return an array directly.

The implementation of this is:

Admittedly, the syntax looks awful.  Indeed, some explanation is necessary.

First, the top-level stuff

says “_ArraySizeHelper is a function that returns a reference (note the &) to a char array of N elements”.

Next, the function parameter is

which is a reference to a T array of N elements.

Finally, countof is defined as the size of the result of the function _ArraySizeHelper.  Note we don’t even need to define _ArraySizeHelper(), -- a declaration is enough.

With this new definition,

becomes valid, just as we desire.

Am I happy now?  Well, I think this definition is definitely better than the others we have visited, but it is still not quite what I want.  For one thing, it doesn’t work with types defined inside a function.  That’s because the template function _ArraySizeHelper expects a type that is accessible in the global scope.

I don’t have a better solution.  If you know one, please let me know.

BTW, how does one solve the same problem for C#?  It’s trivial there.  You just say “x.length()” (I forgot the actual syntax, but you should get the idea).

One thing to point out is that, in C# the count of an array is not in its type.  You decide how many elements are there when you create the array at run time.  Therefore, don’t even try to derive this information at compile time.

P.S. John Gibbs provided this link to another interesting application of the C++ template type system: A Portable typeof Operator by Bill Gibbons.

P.P.S. FC++ uses C++ templates in an ingenious way.  This one is my favorite.

Since the release last Monday, we have seen that some users failed to download this product.  The top reasons include:

1. The user cancelled the download.

Please be reminded that you are downloading a large product, for example, the documentation component (MSDN express) itself is over 150 MB.  And, given the volume of download we are receiving, sometimes the progress will be very slow and it may look like hanging.  Give it more time and you have a good chance of eventually finish the download.

2. The BITS service is disabled on the machine.

The VS express web setup relies on the BITS (Background Intelligent Transfer Service) service on the user's machine to download the setup files.  BITS is enabled by default when you install Windows, but some user may choose to disable it for “performance gain”.  This is not necessary as BITS is taking very little resource.  You need to enable BITS before trying to install VS express over the web.

3. The user is not logged on.

Some users are trying to run VS express web setup under other's identity by using the “runas” command.  This is not supported by BITS.  You have to be logged on interactively.  Another unsupported scenario is running the setup in a Terminal Server session into a Windows 2000 server machine.  (Terminal Server into Windows XP and Windows 2003 server is fine.)

I would love to hear your suggestions and comments on best software development practice, and what you think we can do to improve the quality of a software project that involves millions of lines of code.  Do you have a story to share?  That would be great.

Before Aaron switched team, he was a QA lead in the VS / .NET setup team, which I'm working for.  He was a great resource then.  Looks like his posts will be a new valuable source of information for my work.  I expect them to be useful to anyone interested in setup technologies as well.

In particular, he recommended this article on MSI component rules written by Rob Mensching.  It's 11pm and I need to rest now, but the first thing on Monday I'm gonna read it and save it in OneNote for future reference.

The question is simple: given a C++ array (e.g. x as in int x[10]), how would you get the number of elements in it?

An obvious solution is the following macro (definition 1):

I cannot say this isn’t correct, because it does give the right answer when you give it an array.  However, the same expression gives you something bogus when you supply something that is not an array.  For example, if you have

          int * p;

then countof( p ) always give you 1 on a machine where an int pointer and an int have the same size (e.g. on a Win32 platform).

This macro also wrongfully accepts any object of a class that has a member function operator[].  For example, suppose you write

then sizeof( x ) will be the size of the x object, not the size of the buffer pointed to by x.p.  Therefore you won’t get a correct answer by countof( x ).

So we conclude that definition 1 is not good because the compiler does not prevent you from misusing it.  It fails to enforce that only an array can be passed in.

What is a better option?

Well, if we want the compiler to ensure that the parameter to countof is always an array, we have to find a context where only an array is allowed.  The same context should reject any non-array expression.

Some beginners may try this (definition 2):

They figure, this template function will accept an array of N elements and return N.

Unfortunately, this doesn’t compile because C++ treats an array parameter the same as a pointer parameter, i.e. the above definition is equivalent to:

It now becomes obvious that the function body has no way of knowing what N is.

However, if a function expects an array reference, then the compiler does make sure that the size of the actual parameter matches the declaration.  This means we can make definition 2 work with a minor modification (definition 3):

This countof works very well and you cannot fool it by giving it a pointer.  However, it is a function, not a macro.  This means you cannot use it where a compile time constant is expected.  In particular, you cannot write something like:

Can we do anything about it?

Someone (I don’t know who it is – I just saw it in a piece of code from an unknown author) came up with a clever idea: moving N from the body of the function to the return type (e.g. make the function return an array of N elements), then we can get the value of N without actually calling the function.

To be precise, we have to make the function return an array reference, as C++ does not allow you to return an array directly.

The implementation of this is:

Admittedly, the syntax looks awful.  Indeed, some explanation is necessary.

First, the top-level stuff

says “_ArraySizeHelper is a function that returns a reference (note the &) to a char array of N elements”.

Next, the function parameter is

which is a reference to a T array of N elements.

Finally, countof is defined as the size of the result of the function _ArraySizeHelper.  Note we don’t even need to define _ArraySizeHelper(), -- a declaration is enough.

With this new definition,

becomes valid, just as we desire.

Am I happy now?  Well, I think this definition is definitely better than the others we have visited, but it is still not quite what I want.  For one thing, it doesn’t work with types defined inside a function.  That’s because the template function _ArraySizeHelper expects a type that is accessible in the global scope.

I don’t have a better solution.  If you know one, please let me know.

BTW, how does one solve the same problem for C#?  It’s trivial there.  You just say “x.length()” (I forgot the actual syntax, but you should get the idea).

One thing to point out is that, in C# the count of an array is not in its type.  You decide how many elements are there when you create the array at run time.  Therefore, don’t even try to derive this information at compile time.