Advanced C++ Community

Hardware independent (sort of) compare and swap?

2007-12-23T23:21:39Z

Is anyone aware of an existing free-as-in-beer codebase that provides an abstraction for compare-and-swap across common hardware types?

I am writing a fairly simple lock-free buffer type and would like to avoid doing the assembler myself. The platforms which I have an immediate interest in supporting are x86 and SPARC v9: nothing exotic.

I've done some hunting and pleasingly it looks like these atomic ops are quite likely to go into the C++ standard at some point (in C++0F or whatever), however I can't find anything concrete in terms of an implementation yet.

New to threads

2007-12-21T02:08:32Z

I've never written any threaded applications before, but I have one that could probably benefit from it. I'm looking at converting it over using Boost.

I have found the Dr. Dobbs article, which seems to have the best and most numerous examples of Boost threading, but I'm still unclear on how to actually get the different threads to execute in parallel. I'm really just starting out here, so maybe I'm just misinterpreting, but it looks like in the examples the threads are executed serially, which doesn't make any sense. I must misunderstand something.

I admit my impatience with reading the whole article in detail, because my particular application seems--to my naive self--to naturally avoid the major pitfalls of threading.

Basically, it creates a collection of Recipients, and for each recipient:
- queries for some information to email to the recipient
- emails the information to the Recipient
- deletes the database records that led to the email being sent (no two recipients will share a record, and this is MySQL, so there will be no table locks)
- logs the sending of the email in another database table
- updates a record of the last time the user received an email

Rather than processing each recipient serially in a loop, I'd like to be able to spawn a thread for each recipient. I'm thinking that I need to combine all of the per-recipient tasks into a single function and then spawn a new thread of that function for each recipient. Am I on the right track? Do I need to use a thread_group so I can dynamically create threads rather than instantiating specific named threads, as is done in all of the Dr. Dobbs examples?

Here is the gist of the application. The mailer is a functor.

  try {
    bool recipients_found = load_recipient_data();
    if (recipients_found) {
      Summary_Mailer mailer(get_url_domain(), get_bounce_address(), destination_template, mail_drop, verbose);

      for (summary_recipient_hash_map::iterator recipient_it = recipients.begin(); recipient_it != recipients.end(); ++recipient_it) {
        set_recipient_documents(&(recipient_it->second));

        if (!recipient_it->second.documents.empty()) {
          mailer(&(recipient_it->second));
          cleanup_research_summary_email(recipient_it->second);
          insert_email_sent_summary_research_activity(recipient_it->second);
        }

        update_user_research_summary_options(recipient_it->second);
      }
    }

    user_db.logoff();
    document_db.logoff();

  }

Any applicable advice appreciated. Alliteration optional.

Callback for something that might disappear

2007-10-21T08:31:55Z

I wanted to have a fairly robust callback that would call something that might disappear before the callback is triggered. I wanted the callback to simply go dead when its target disappeared.

I thought about it a lot, and I came up with this:

#include <boost/function.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/lambda/core.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/if.hpp>
#include <iostream>

using ::std::cout;

class existence_guardmaster {
   class guard_t;
   class isvalid_wrapper;
   friend class isvalid_wrapper;
   friend void intrusive_ptr_add_ref(guard_t *);
   friend void intrusive_ptr_release(guard_t *);
   typedef ::boost::intrusive_ptr<guard_t> guardptr_t;

 public:
   typedef ::boost::function<void (void)> wrapped_t;

   existence_guardmaster(bool startvalid = true);
   ~existence_guardmaster();

   bool isvalid();
   void setinvalid();
   void setvalid();

   const wrapped_t wrap_with_guard(const wrapped_t &func) const;

 private:
   const guardptr_t guard_;
};

class existence_guardmaster::guard_t {
   friend class existence_guardmaster;
   friend void intrusive_ptr_add_ref(guard_t *);
   friend void intrusive_ptr_release(guard_t *);
   bool valid_;
   unsigned int refs_;

   guard_t(bool startvalid) : valid_(startvalid), refs_(0) { }
   bool isvalid() const {
      return(valid_);
   }
   void setinvalid() {
      valid_ = false;
   }
   void setvalid() {
      valid_ = true;
   }
};

inline existence_guardmaster::existence_guardmaster(bool startvalid)
     : guard_(new guard_t(startvalid))
{
}

inline existence_guardmaster::~existence_guardmaster()
{
   guard_->setinvalid();
}

inline bool existence_guardmaster::isvalid()
{
   return guard_->isvalid();
}

inline void existence_guardmaster::setinvalid()
{
   guard_->setinvalid();
}

inline void existence_guardmaster::setvalid()
{
   guard_->setvalid();
}

class existence_guardmaster::isvalid_wrapper {
 public:
   typedef void result_type;
   isvalid_wrapper(const guardptr_t &ptr, const wrapped_t &func)
        : ptr_(ptr), func_(func)
   {
   }
   void operator ()() const { if (ptr_->isvalid()) func_(); }
 private:
   const guardptr_t ptr_;
   const wrapped_t func_;
};

inline const existence_guardmaster::wrapped_t
existence_guardmaster::wrap_with_guard(const wrapped_t &func) const
{
   return isvalid_wrapper(guard_, func);
}

inline void intrusive_ptr_add_ref(existence_guardmaster::guard_t *guardp)
{
   ++(guardp->refs_);
}

void intrusive_ptr_release(existence_guardmaster::guard_t *guard)
{
   if ((guard->refs_ <= 0) || (--(guard->refs_) <= 0)) {
      delete guard;
   }
}

static inline void thefunction()
{
   ::std::cout << "Called!\n";
}

int main(int argc, char *argv[])
{
   existence_guardmaster master;
   existence_guardmaster::wrapped_t wf = master.wrap_with_guard(thefunction);
   wf();
   master.setinvalid();
   wf();
}

This results in a lot of overhead per call though. More than I was expecting. And the other problem is that callback functions are limited to functions with a certain signature. You could use boost::bind to bind all the arguments to your callback and store them away safely so it looked like it was void (void), but that seems inelegant and like it wouldn't work well for some situations.

It's pretty easy to do f(g(x)) in boost, but not so easy to do f(g)(x) when f is something that creates a function that largely just needs to pass things along to g.

Is there a way around this?

Tiered Debugging

2007-08-27T10:10:11Z

First off, I would like to thank everyone for the discussion back in the Debugging post

Here is the abbreviated overview of what I created:

Fine grained modularity
Multiple levels of debugging may coexist. The developer may have everything
controlled from the global scope, all the way down to each debug macro having
its own separate state. (Though, doing the latter would probably create a
maintenance nightmare.)

Message stream inserters
Anywhere the macro variable "message" appears, stream inserts (operator <<())
may be used. Thus, for example:

int n = 5;
TD_LOG("current value of n: " << n);

Static compilation
Since every aspect of the structs used to control the behavior of Tiered Debug
are statically defined, the compiler can eliminate any superfluous code.

You can download the code and unit test from here.

If anyone thinks I should clarify the documentation or add in specific examples, go ahead and tell me.

Debugging

2007-08-13T12:11:00Z

I've been thinking about ways to allow differing amounts of information to be displayed while debugging a program. And thus I came up with this possible solution. I would like to hear what other people have to think, and would greatly welcome any constructive criticism.


#ifdef DEBUG_FULL
#   define ASSERT_VERIFY(test, message)     do { assert((test) && (message)); } while(0)
#   define LOG_DEBUG(message)               do { Log(message); } while (0)
#   define LOG_VERIFY(test, message)        do { assert((test) && (message)); } while (0)
#   define THROW(ex, message)               do { assert(!(message)); } while (0)
#elseifdef DEBUG_EXTENDED
#   define ASSERT_VERIFY(test, message)     do { assert((test) && (message)); } while(0)
#   define LOG_DEBUG(message)               do { Log(message); } while (0)
#   define LOG_VERIFY(test, message)        do { if (!(test)) Log(message); } while (0)
#   define THROW(ex, message)               do { throw ex(message); } while (0)
#elseifdef DEBUG_REGULAR
#   define ASSERT_VERIFY(test, message)     do { assert((test) && (message)); } while(0)
#   define LOG_DEBUG(message)               do {} while (0)
#   define LOG_VERIFY(test, message)        do { if (!(test)) Log(message); } while (0)
#   define THROW(ex, message)               do { throw ex(message); } while (0)
#elseifdef DEBUG_RELEASE
#   define ASSERT_VERIFY(test, message)     do { if (!(test)) Log(message); } while(0)
#   define LOG_DEBUG(message)               do { Log(message); } while (0)
#   define LOG_VERIFY(test, message)        do { if (!(test)) Log(message); } while (0)
#   define THROW(ex, message)               do { throw ex(message); } while (0)
#else // release version
#   define ASSERT_VERIFY(test, message)     do {} while(0)
#   define LOG_DEBUG(message)               do {} while (0)
#   define LOG_VERIFY(test, message)        do { if (!(test)) Log(message); } while (0)
#   define THROW(ex, message)               do { throw ex(message); } while (0)
#endif

DEBUG_REGULAR would be used day to day during development. It has the following properties:
ASSERT_VERIFY will halt the program if the test fails.
LOG_DEBUG does nothing.
LOG_VERIFY logs any information if the test fails. This functionality would be used in the cases where a recoverable error occurs.
THROW throws the specified exception.

DEBUG_EXTENDED acts like DEBUG_REGULAR, except LOG_DEBUG now sends information to the log. This way, LOG_DEBUG can be used to send out state information that would normally clutter up the log.

DEBUG_FULL would be used when you want the application to halt when any error is detected.

DEBUG_RELEASE would be used when you want to track down an obscure bug, but you don't want to have the application arbitrarily halt. The major use of this would be to send it to end users, and have them record their actions while recreating a bug. ASSERT_VERIFY now acts like LOG_VERIFY

RELEASE would be the standard version to give to the public. ASSERT_VERIFY is deactivated since you don't want the program to simply halt. LOG_DEBUG is also deactivated

Just a funny peace of code. How you compiler processes it?

2007-04-06T17:37:34Z

struct A {
};

template<typename TList>
struct MultipleInheritance :
public TList::Head,
public MultipleInheritance<typename TList::Tail>
{
};

template <typename T1>
struct RecTList {
typedef T1 Head;
typedef RecTList< RecTList<T1> > Tail;
};

typedef RecTList<A> ARecTList;

class RectClass : public MultipleInheritance<ARecTList> {};

int main() {
return 0;
}

Psuedo Stack Trace Via Exceptions

2006-12-06T03:22:03Z

In my post on (bad) optimizations, iamo gifted us with the neat trick of catching exceptions that are thrown in constructor lists (link).

This got me thinking about supporting some type of stack trace in exceptions. Here are my musings:

1) The stack trace would be manual. I.E., I would need to decided where I wanted a trace to occur, explicitly add the stack info, and propagate it.
For example:

try {
    // bunch of stuff
    }
catch (foo &ex)
    {
    // handle foo
    }
catch (...)
    {
    // add stack info and propagate
    }

2) I would need to implement my own exceptions classes. (Not a problem, as I have already done that for other various reasons.)

3) The simplest way would be to use a linked list for the stack trace info. Thus, when an exception is to be propagated, I could easily add the info into the list, and throw a new exception / rethrow the current exception.

Has anyone else done this? Do anyone have pointers / hints?

Optimizations

2006-11-11T14:42:07Z

I came across this page of C++ optimizations recently (http://www.custard.org/~andrew/optimize.php). Some of them I consider to be fair, while others I consider to either have hidden pitfalls, or possibly even flat out wrong. Below is a list of my reactions. I would like to hear other people's opinions. Especially if I missed a pitfall or misinterpreted what the optimization was for.

Use Initialization Lists - I agree with this one. The author doesn't mention that to initialize a const object, you pretty much have to use initialization lists.

Optimize For Loops - this optimization will create an infinite loop if the variable is unsigned. Also, preferring ++i over i++ is most important if they are being applied to a class. When applied to a built in, they have the same efficiency if the return value is not used.

Use Int - I prefer to use types that specify their bit size. I've seen bugs pop up where due to the fact that int was not the expected bit size.

Make Local Functions Static - actually, they should be put into an anonymous namespace. The only time I use a static variable is for something like singletons.

Optimize If Statements - I consider this advice to be a true WTF. Can anyone give me both a general case and and a specific case example where following the authors advice would give a speed improvement?

Optimize Switch Statements - won't hurt.

Avoid Expensive Operations - this one is obvious to more experience programmers. However, it also makes me think about the adage of premature optimizations.

Initialize on Declaration - always a good idea,

Pass By Reference - fails to point out that the variable passed in may be changed by the function. And that this can be prevented by making the variable const. Or that built in types do not need to be passed in by reference unless they are being changed.

Delay Variable Declarations - I agree with this one completely.

'op=' - This one is true also. Though some (most?) compilers will optimize this for you.

Inline Small Functions - Possible code bloat should be a concern.

Use Nameless Classes - If I am constantly using nameless classes in my code, it would make me wonder if I should start refactoring the code. Otherwise, I do agree that a nameless class is better than a temp variable.

Lint tools on Windows?

2006-11-02T21:04:13Z

I saw the comments to a recent entry here talk about lint tools. Do any of you use some form of lint regularly (and do they help you a lot)?

And are there any free ones available for windows and/or osx, that handle C++? I searched for them a few times, and IIRC, I only found one free one that would run on Windows, that handled C only.

Am I nuts?

2006-10-25T16:21:52Z

I'm rather offended, having been bitten by this bug. Why is it even allowed to take a reference to a const reference, if it could be a copy?!?

#include <assert.h>

class Blah
{
public:
  const unsigned int &myfoo;
  Blah(const unsigned int &p):
    myfoo(p) {}
  const unsigned int getfoo()
  {
    return myfoo;
  }
};

int main()
{
  int foo(42);
  Blah baz(foo);

  ++foo;

  assert(foo == baz.getfoo());

  return 0;
}

Counter of C/C++ source lines and bytes

2006-10-06T08:51:29Z

Counter of C/C++ source lines and bytes
https://sourceforge.net/projects/cncc/

NAME
cncc - count C/C++ source lines and bytes

SYNOPSIS
cncc [OPTIONS]... [FILE]...

DESCRIPTION
Count code-lines, empty-lines, comment-lines,
code-fields, empty-fields, comment-fields of C/C++-sources
which have been successfully compiled.

The program accepts the following options.

`-a'
Print code-line, empty-line and comment-line counts for each FILE.
This option is DEFAULT.

`-b'
Print line-type for each LINE of each FILE.

`-c'
Print
* line-type
and
* code-field, empty-field and comment-field counts
for each line of each FILE.
### Note. This option is incompatible with option `-d'.

`-d'
Print field-type for each field of each line of each FILE.
### Note. This option is incompatible with option `-c'.

`-h'
Display this help and exit.

`-v'
Print the version number and exit.

C/C++ Program Perfometer

2006-10-01T07:11:32Z

The C/C++ Program Perfometer is an open source tool which enables the programmer to measure the comparative performance of a C/C++ program or of separated pieces of code by one of several desired metrics: e.g., time, memory, or metrics defined by the programmer.

C/C++ Program Perfometer has been referenced at the C++ Standards Committee site:
http://www.open-std.org/jtc1/sc22/wg21/docs/18015.html
(information announcing C++ - TR 18015 Technical Report on C++ Performance).

Subscribe to comp.lang.c++.perfometer

Email:

Browse Archives at groups.google.com

Riddle Me This

2006-08-15T14:52:00Z

Correct me if I'm wrong but aren't programmers just highly intelligent people paid to play with lego?

DevPartner or?

2006-07-22T17:51:52Z

Is there a way to export the output report of the DevPartner (leaks) to any open format, like XML, etc... sorry for the offtopic. I just don't think any other community could possibly help.

Pipelining numerical computation

2006-04-11T15:36:46Z

How do you efficiently vectorize std::valarray?

I'm not sure how common this concept is, but it's something I've used for a couple years now for Fun and Profit. Some while back I wanted to write my own implementation of std::valarray that could use SIMD instructions to improve performance. Given a compiler with SIMD intrinsics (I used gcc at the time) there is a fairly straightforward direct implementation; you simply implement the mathematical operations by looping over the data, loading it up into SIMD registers and performing your computation. Now, for simple code such as

a = b + c;

this is fine. But what about a more complex expression? To use a trivial example, how about just evaluating a quadratic over a large amount of data?

y = a * x * x + b * x + c;

In these more complex expressions the trivial implementation falls flat on its face, and your program ends up wasting a ton of time copying data between memory and registers unnecessarily. If we consider our data in tabular form...

a₁	x₁	x₁	b₁	x₁	c₁
a₂	x₂	x₂	b₂	x₂	c₂
a₃	x₃	x₃	b₃	x₃	c₃
...

the trivial implementation is evaluating the expression by computing down pairs of columns, storing the intermediate values in memory each time. Ideally what we want to do is perform the computation in groups of rows, allowing us to maintain intermediate values in registers and cutting down memory use to a bare minimum.

My solution to this is what I termed 'pipelining'. Instead of directly evaluating the data, we delay computation, instead taking the expression and using it to construct a functor which describes the calculation we want to perform, thus creating a pipeline. The computation then occurs only on demand (i.e., when you attempt to take its value) at which point data can be fed into the pipeline in chunks. Each of these SIMD-register sized chunks can then be fully evaluated before moving onto the next chunk.

The basis of the code is to encapsulate raw data in an object like:

template <class T, unsigned int BlockSize>
struct _vec_data : public _vec_expr_comp<T, BlockSize>
{
  const unsigned int size;
  _vec_block<T, BlockSize> *const data;

  _vec_data(unsigned int s) :
    size(s), data(new _vec_block<T, BlockSize>[s])
  {}

  _vec_data(const _vec_data& o) :
    size(o.s), data(o.val)
  {}

  _vec_block<T, BlockSize> val(unsigned int i)
  {
    return data[i];
  }
};

Where _vec_block is a simple structure containing a single block of data (sized for your SIMD registers).

Then, you implement your operands:

template <class T, unsigned int BlockSize, class Op, class P1, class P2>
struct _vec_expr_bin : public _vec_expr_comp<T, BlockSize>
{
  const Op oper;
  const P1 param1;
  const P2 param2;

  _vec_expr_bin(P1 p1, P2 p2) :
    param1(p1), param2(param2), oper()
  {}

  _vec_block<T, BlockSize> val(unsigned int i)
  {
    return oper(param1.val(i), param2.val(i));
  }
};

template <class T, unsigned int BlockSize, class Op, class P>
struct _vec_expr_un : public _vec_expr_comp<T, BlockSize>
{
  const Op oper;
  const P param;

  _vec_expr_bin(P p) :
    param(p), oper()
  {}

  _vec_block<T, BlockSize> val(unsigned int i)
  {
    return oper(param.val(i));
  }
};

_vec_expr_comp is where the magic occurs in. It's also going to be a very large class, so I won't write the whole thing out.

template <class T, unsigned int BlockSize>
struct _vec_expr_comp
{
  ...

  template<class P1, class P2>
  _vec_expr_bin<T, BlockSize, VecAddOp, P1, P2> operator + (const P1& p1, const P2& p2)
  {
    return _vec_expr_bin<T, BlockSize, VecAddOp, P1, P2>(p1, p2);
  }

  template<class P>
  _vec_expr_un<T, BlockSize, VecUnaryMinus, P> operator - (const P& p)
  {
    return _vec_expr_bin<T, BlockSize, VecUnaryMinus, P1, P2>(p);
  }

  ...
};

Repeat those member-functions for every operator you want to implement (take similar steps for other mathematical functions you'd like to support). Finally, we move onto the actual valarray-style class.

template <class T>
class valarray : public _vec_expr_comp<T, machine::BlockSize>
{
  ...

  template<class T>
  valarray& operator = (const T& vexpr)
  {
    // do a test to make sure T is derived from _vec_expr_comp if you want

    for (unsigned int i = 0; i < size() / machine::BlockSize; i++)
    {
      _vec_block<T, machine::BlockSize> block = vexpr.val(i);

      for (unsigned int j = 0; j < machine::BlockSize; j++)
	data[i * machine::BlockSize + j] = block.data[j];
    }
  }

  ...
};

There are other evaluation operators that need to be implemented, such the *= and similar operators, and a cast operator on _vec_expr_comp so that intermediate expressions can be treated as instances of the valarray class.

Obviously, the machine structure or namespace holds the machine-specific code, and I won't elaborate on that. Also, you need to be a little more careful than I've been in these examples when you reach the end of your data, as your last calculation may not be register-sized. In this case you may need to take precautions to avoid mishaps such as accidental divide by zero errors. Also, you can't produce an exact valarray implementation with this technique, but you can create an almost-alike implementation. Slices are tricky to get right!

The end result of this is that we, as stated above, are able to perform computations on subchunks at a time, letting us manage our memory usage more efficiently. This isn't my actual code, although on my 2ghz P4 I've found that my pipelined/vectorized valarray is between 4 and 12 times faster than the stock gcc valarray, depending on specific expression.

Anyway, I hope you found this interesting! It was certainly a fun challenge trying to figure out how to do it.

-jep.

P.S. Don't forget to run with your compiler optimisations on high when you do this and spread inline keywords liberally. It needs heavy function inlining to be efficient.

( X-posting in cpp )

C++0x

2006-04-11T05:58:43Z

What's your opinion of the new stuff coming down the pike from the standards committee? Specifically, what do you think of Concepts? For those of you who are unfamiliar with some of the new things arriving in your next C++ standard, here is a brief summary.

Discuss.

A question about derivation and virtual functions

2006-04-10T19:02:20Z

I was surprised by the output of this code using MSVC++ 6:

#include <iostream>

struct t1      {virtual int id() {return 1;}};
struct t2 : t1 {        int id() {return 2;}};
struct t3 : t2 {        int id() {return 3;}};

int main() {
   t1 i1;
   t2 i2;
   t3 i3;
   t1& i4 = i2;
   t1& i5 = i3;
   t2& i6 = i3;
   std::cout << i1.id() << ' '  << i2.id() << ' '  << i3.id() << ' '
             << i4.id() << ' '  << i5.id() << ' '  << i6.id() << std::endl;
   return 0;
   }

I expected the output to be 1 2 3 2 2 2; it was 1 2 3 2 3 3. Since id() is not virtual in t2, how can it be overridden in i5, and especially in i6?
This makes so little sense to me, I’m wondering if it’s a compiler error. Does anyone know?

advancedcpp @ 2006-03-24T17:11:00

2006-03-24T15:17:40Z

Today I was asked for simple example of using ADO, C++ and MS SQL Server. I tried to do something understandable, but it is really hard to use ADO in C++.
I have developed solution for this purpose for my company, but it is a set of wrappers for easy using.
I think all of us, who uses ADO in C++, have it's oun unique collection of such libraries :) Am I right? Guys, let's share our experience.
Maybe it would be good to develop some simple and good library that uses ADO as data access library in the heart and upload as GPL to SF.NET.
What you think about it? There is a "simple" example I gave to my friend to enable him to understand how it works :)

// --*-- C++ --*--
//
// The simple C++ example of using Microsoft ADO C++ interface with MS SQL Server.
//
// Copyright (c) 2006 by Vladislav Lazarenko <snail@b2bits.com>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//

#include <exception>
#include <string>
#include <iostream>

#include <boost/noncopyable.hpp>

#ifndef _ATL_NO_UUIDOF
# define _ATL_NO_UUIDOF
#endif

#ifndef _WIN32_DCOM
# define _WIN32_DCOM
#endif

#include <comutil.h>
#include <comdef.h>
#include <comutil.h>

// NOTE: '$(CommonProgramFiles)\System\ADO' should be used as additional include directory.
#import "msado15.dll" rename("EOF", "EndOfFile")

/// Unnamed namespace.
namespace
{
/// This class is designed to easy use of COM exception, for example, as std::exception.
/// COM exception is a little bit too hard to manage, enjoy this simple wrapper.
class ComException : public std::exception
{
public:
    /// Constructor.
    /// @throw std::exception on errors with COM error description extract.
    /// @param e COM error object.
    ComException(const _com_error & e) : std::exception(getErrorDescription(e).c_str()) {}

    /// Destructor.
    virtual ~ComException() {}

    /// Tests the COM operation return code and raise error if something went wrong.
    /// @param res COM operation return code.
    /// @throw ComException if something went wrong.
    static void test(HRESULT res)
    {
      if (FAILED(res))
        issue(res);
    }

    /// Issues the COM error to be raised as ComException.
    static void issue(HRESULT res)
    {
      try
      {
        _com_issue_error(res);
      }
      catch(const _com_error & e)
      {
        throw ComException(e);
      }
    }

private:
    /// Extracts the error description from COM error object.
    /// @param e COM error object.
    /// @return Error description.
    static std::string getErrorDescription(const _com_error & e)
    {
      _bstr_t desc = e.Description();
      std::string::size_type descLen = static_cast<std::string::size_type>(desc.length());

      if (descLen > 0)
        return std::string(static_cast<const char *>(desc), descLen);
      else if (const char *errMsg = e.ErrorMessage())
        return errMsg;
      else
        return "Unknown COM error";
    }
};

/// To use ADO in C++ we need to initialize COM library.
/// This class designed to easy initialization.
/// @note This class can not be copied. I see no needs in this.
class ComInitializer : private boost::noncopyable
{
public:
    /// Constructor.
    ComInitializer()
    {
      ComException::test(
        CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE | COINIT_SPEED_OVER_MEMORY | COINIT_MULTITHREADED));
    }

    /// Destructor.
    ~ComInitializer()
    {
      CoUninitialize();
    }
};

/// ADO connection object wrapper.
/// As you can understand, using ADO for a long time made me very lazy developer.
/// I am not going to enjoy hard to use Microsoft library, so have written my own wrappers
/// to make life better.
/// This class represents the ADO connection object.
/// @note Connection object can not be basically copied.
///       Use shared pointers if you want to share connections.
class Connection : private boost::noncopyable
{
public:
    /// Constructor.
    /// @param connectionString ADO connection string to connect to the database.
    /// @note Connection would be established on construction.
    /// @throw ComException on errors.
    Connection(const std::string & connectionString)
    {
      ComException::test(conn_.CreateInstance(__uuidof(ADODB::Connection)));
      ComException::test(conn_->put_CursorLocation(ADODB::adUseClient));
      ComException::test(conn_->Open(_bstr_t(connectionString.c_str()), L"", L"", ADODB::adConnectUnspecified));
    }

    /// Destructor.
    ~Connection()
    {
      try
      {
        conn_->Close();
      }
      catch(const _com_error &) {}
    }

    /// Executes the simple SQL statement that does not return the result.
    /// For more advanced execution refer to the documentation.
    /// @param statement SQL statement to execute.
    void executeStatement(const std::string & statement)
    {
      try
      {
        ADODB::_CommandPtr command;

        ComException::test(command.CreateInstance(__uuidof(ADODB::Command)));
        command->Prepared = false;
        command->PutRefActiveConnection(conn_);
        command->PutCommandText(_bstr_t(statement.c_str()));
        command->Execute(NULL, NULL, ADODB::adCmdText | ADODB::adExecuteNoRecords);
      }
      catch(const _com_error & e)
      {
        throw ComException(e);
      }
    }

private:
    /// ADO connection object.
    ADODB::_ConnectionPtr conn_;
};

/// Single database access point for the application.
class DataSource : private boost::noncopyable
{
private:
    /// Constructor.
    /// @param connectionString ADO connection string to connect to the database.
    /// @throw ComException on errors.
    DataSource(const std::string & connectionString) : conn_(connectionString) {}

    /// Destructor.
    ~DataSource() {}

    /// First of all, COM should be initialized.
    /// @note This should be declared first to be initialized before all other.
    ComInitializer com_;

    /// Connection used to access the database.
    Connection conn_;

public:
    /// Gets the instance of the connection stored in data source.
    /// @throw ComException on errors.
    static Connection & instance()
    {
      static DataSource instance_("Provider=SQLOLEDB;Data Source=(local);initial catalog=Blue;uid=blue;pwd=blue123");
      return instance_.conn_;
    }
};
}

/// The entry point of console application.
int main()
{
try
{
    DataSource::instance().executeStatement("SELECT GETDATE() AS DATE");
    DataSource::instance().executeStatement("SELECT GETUTCDATE() AS DATE");
}
catch(const std::exception & e)
{
    std::cerr << "ERROR: " << e.what() << std::endl;
    return 1;
}

return 0;
}

Boost backward compatibility.

2006-03-23T16:43:23Z

Damn, looks like guys from Boost community don't care 'bout backward compatibility. It was boost 1.31. Today I have downloaded and installed boost version 1.33. Just two points up but my project won't compile. In one of my projects I have simple line of the code to check that two types isn't same. Is it so principial, how to write the same code if both ways are easy? As for me - all the same. But why they don't gives a damn 'bout backward compatibility? I don't want to rewrite and recompile my projects each time boost changed :-\

Was:

#include <boost/mpl/assert_is_same.hpp>

...

BOOST_MPL_ASSERT_NOT_SAME(T, std::string);

Now the same thing should be done by the following:

#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/assert.hpp>

...

BOOST_MPL_ASSERT_NOT((boost::is_same<T, std::string>));

advancedcpp @ 2006-03-22T15:57:00

2006-03-22T11:59:52Z

The D language will soon replace c++. http://www.digitalmars.com/d/

Dylan as well but sadly marketing needs to take a whole new ball game for that to happen.

Comments?

XML with non-English encoding

2006-03-19T09:10:46Z

Does smb know any tip?
When I try to parse XML with greek (for example) symbols, - I receive ASCII symbols instead of text.
How can I get to parser know encoding? (it is UTF-8).
Thanks in advance!

advancedcpp @ 2006-03-17T22:49:00

2006-03-18T03:54:39Z

I was trying to write a quine for C++ but couldn't. I still don't get the trick of these. How do you break the cycle of the self referential loop?

Is the MS Development Environment retarded?

2006-02-28T22:06:02Z

I just spent 2 hours on the weirdest problem...
As you might have read in my other post, I am currently writing a C++ program under Linux.
I use putty to compile and run my program on the remote machine but edit the code on my local computer.
When I initially double clicked on the .cpp file, it opened it in Microsoft Development Environment, which I thought would work just fine.

To make a long storry short, somewhere along the way, I formatted the code and it put all those cool tabs in.
It also put a tab at this spot here:
findobject(totalbuf,found,"submit\"Xvalue=\"Next \0","\">\0");
The red x marks what used to be a space and definitely needed to be one for my program to work.
It also looked like a space to me. I was going nuts and didn't know what was wrong until i coincidentally noticed everything jump around after the X when moving the whole line.

I also have those in other places, where they don't seem to matter that much.
Just wanted to point out what a little stupid can do to your time.

Inheritance with no Virtual Functions?

2006-02-18T23:28:00Z

I am working on a C++ wrapper for CFStringRef and CFMutableStringRef.

Note, all calls that accept a CFStringRef also accept a CFMutableStringRef. But any function that requires a CFMutableStringRef will throw an assert() if a mere CFStringRef is passed in. And no, Apple does not provide a function that lets you test for mutability... :-/

The life span of these structs are determined by a reference count. When the count hits zero, they are actually destroyed. The two functions that increase and decrease the reference count are CFRetain() and CFRelease() respectively.

The primary purpose of the wrapper classes I am writing is to automatically handle the calls to CFRetain() and CFRelease().

Making a class to wrap the CFStringRef is straightforward.

The fun comes into the design for the CFMutableStringRef wrapper class. If I inherit from the CFStringRef wrapper class, it has these traits:

1) No additional data fields.
2) All constructors simply call the base class constructors. They do no additional work.
3) The destructor is empty. The base class destructor does all necessary work.
4) There are no virtual functions.

Essentially, the derived class is providing extended functionality.

So, the big questions is: Do I *need* to worry about at least marking the base destructor as virtual.

Or perhaps the better question is: Is there any hidden traps if I don't declare any virtual functions (beyond losing access to the extended member functions should something be upcasted).

brute force

2006-02-16T02:18:42Z

Can you guys give me any pointers, on how I would go about writing a html form brute force application in c++?
This would be used to get into the web interface of my dad's router, who apperantly doesn't know the password and can't find where he notated it.
I would like to forward a port to my server, but don't want to reset the router.

The router is a WR850G (motorola), that has an index.asp with a very simple html form on it.
It shouldn't be too difficult, to write some kind of class, that keeps submitting that form and checks the returned data right?
I would be happy if someone can point me in the right direction or give me any starting points.

ps: don't worry about passwords; i am just gonna keep counting up the letters basically from 00000000 to ZZZZZZZZ until it fits. I'm on the same LAN, so connection is fast and time is irelevant.
pss: i tried a cuppl programs already, AccessDriver seeming the most sufisticated, but had no success, also those programs require a file with passwords and usernames. i would just like to create those while brute forcing; maybe saving the current possition every 500 passwords or so.
Thx a lot.