C / C++ / MFC

#include <boost/type_traits.hpp>
#include <iostream>

template <typename T>
class foo {
public:
    foo(typename boost::add_pointer<typename boost::remove_reference<T>::type >::type items)
    {
      // Do Stuff
    }
};

int main()
{
   int aa;
   foo<int> a(&aa);
   foo<int&> b(&aa);
}

template<class T>
struct add_pointer
{
   typedef T* type;
};

template<class T>
struct add_pointer<T&>
{
   typedef T* type;
};

template <typename T>
class foo<T&>
{
...
};

Member 4399131 wrote:

I assumed that the problem isn't in my coding technique, it must be generally in the algorithm I use!!!

Member 4399131 wrote:

Does somebody know a better algorithm to implement FindOneOf???

CString str2[] = { "1234567890", "qwtyupzxghiocervbasdjklfnm", "qwo123ertyui45", "qwzxy1uldfghjk2bnm3ertcviopas" };

int index = 0;
CFString str1("abcdefghijklmnoprstuzxwvqyqwertyuio0987654321");

int i = 0;
int start = GetTickCount();
for(int pos = 0; pos < 100000000; pos++)
{
    index = 0;
    index = str1.FindOneOf(str2[pos % 4]);
}
int time = GetTickCount() - start;

CString strTime;
strTime.Format("%d, %d", time, index);
m_editResult.SetWindowText(strTime);

Member 4399131 wrote:

It seems the the test code wasn't appropriate

Member 4399131 wrote:

Do you think that this test code is more accurate?

Member 4399131 wrote:

And about the MS Lookup table I look at it too and I wonder if that's quite legal, I mean that according to my assembly book the instruction BTS sets a bit in the target pointed by its position BUT MAX POSITION IS 31!!! in this case they set bits in a larger memory block by setting positions up to 255 - I wonder how this works, it does obviously?! Maybe my assembly book is obsolete

Stuart Dootson wrote:

switch between the two implementations dynamically

Stuart Dootson wrote:

if you use an immediate operand, you're limited to 0-31. If you use a register operand, the limits disappear

Member 4399131 wrote:

I seeeee! this detail wasn't written in my source - that's a reason to find some more complete one.

Skippums wrote:

The lookup table idea is a great one for ASCII strings... I was only thinking in terms of unicode.

int FindOneOf( const char* pString, const char* pSearch )
{
    register char cMask = -1;
    register char cPattern = *pSearch;
    register int nPos;
    int nSPos;
    int nRet = -1;

    for( nPos = 1; pSearch[nPos]; ++nPos )
    {
        cMask &= ~(pSearch[nPos - 1] ^ pSearch[nPos]);
        cPattern |= pSearch[nPos];
    }
    // cMask now contains '1's in bits that have the same value for every char in pSearch string

    // Check each char in pString
    for( nPos = 0; pString[nPos]; ++nPos )
    {
        // Find out which bits have the same values by '~(pString[nPos] ^ cPattern)'
        // Mask the bits of interest and compare with the mask
        if( (~(pString[nPos] ^ cPattern) & cMask) == cMask )
        {
            // We have a possible match, now walk through the search string
            for( nSPos = 0; pSearch[nSPos]; ++nSPos )
            {
                if( pString[nPos] == pSearch[nSPos] )
                {
                    // A match was found, update return value and get out
                    nRet = nPos;
                    break;
                }
            }
            if( nRet != -1 )
            {
                break;
            }
        }
    }

    return nRet;
}

Member 4399131 wrote:

You actually bother yourself to write and test this code to help me

Member 4399131 wrote:

Well I think I beat the standard runtime library!!!

Roger Stoltz wrote:

It would be really nice to write it in C/C++ in such way that the compiler would generate the same tight code. That would make it more portable.

Roger Stoltz wrote:

I'm not aware of any statement in C that would make use of assembly bit manipulation instructions with bit numbers higher than e.g. 31 on a 32-bit system.

//Set bit...
inline void operator [] (void* pBitTable, int index)
{
   __asm
   {
      mov EAX, index
      bts pBitTable, EAX
   }
};

//Test for bit...
inline bool operator [] (void* pBitTable, int index)
{
   __asm
   {
      mov EAX, index
      bt  pBitTable, EAX
      jb  True
      xor EAX, EAX
      jmp Skip
True: mov EAX, 1
Skip:
   }
};