You can add a using statement to promote the visibility of the base class functions. class CDerivedClass : public CBaseClass { public: CDerivedClass(void) {} using CBaseClass::DoSomething; virtual ~CDerivedClass(void) {} virtual void DoSomething(int a) {} }; The eliminates the "hiding" problem.

Actually, this code has a somewhat subtle behavior, since it is catching by-value, prior to throwing. If a derived exception is thrown, it will be "clipped" to the base class when it is thrown. This could be potentially different from invoking throw, which would throw the derived class.

One other characteristic of C# to keep in mind is that JIT compilation introduces unpredictable execution times. This is probably more noticeable in small embedded environments such as WinCE platforms. I have experienced "hits" of 100+ msec while small functions are compiled, other times they require only 20+ msecs to execute. Apparently the WinCE CLR provides only a relatively small buffer (64K?) of compiled code. When this becomes full, something must be purged to compile the next new block. So you see the "hit" somewhat unpredictably. Also no way to generate pre-compiled binaries (genx) in WinCe.

I have been tasked with generating some inspection / review guidelines (standards) for my current employer. Coding guidelines are pretty simple, but I am struggling with meaningful criteria for guiding review of software product requirements, architecture, preliminary design and detailed designs. I was wondering if anyone had ideas or checklists that they would like to share? I am not looking for generic statements like "Requirements shall be testable.", but rather tips on how to identify when the requirements are design-requirements, rather than functional ones (for example). Similar goals for other types of reviews. If you prefer not to post here, feel free to reply directly to my personal e-mail as well (brothwell@qwest.net). Thanks

Here is a site with general intersection algorithm implementations, including circle with a rectangle (slighly more general case of circle and square) www.geometrictools.com/Intersection.html C++ implementations.

I recently ran thru the same problem you are describing. After researching other discussions, my solution was to implement a "native" event class using the underlying windows CE API. Next, create a thread-safe message queue (using generics in my solution) that signalled an embedded native event when events were added and reset the event when the queue emptied. I used these pieces to implements a WaitForAny on an array of the native handles. Final result was the desired WaitForAny that you are describing.

I was wondering how to find the source code line / filename (__LINE__/__FILE__ equivalent) when using the Compact Framework, since the System.Diagnostics.StackTrace class is not supported? Goal is to support logging of location of errors in release as well as debug. Has anyone found a technique using Trace, perhaps?

I was wondering how to find the source code line / filename (__LINE__/__FILE__ equivlaent) when using the Compact Framework, since the System.Diagnostics.StackTrace class is not supported? Goal is to support logging of location of errors in release as well as debug. has anyone found a technique using Trace, perhaps?

I was wondering if anyone in here could explain what it means when a job description specifies .Net experience? Does that imply a specific version of compiler, language? Specific SDK experience?

Sorry to be vague. Was wondering what generic techniques you use/recommend for implementing conversions between enumberated type values and string representations. Also curious how (of if) you would use a different technique for multi-language support/translation.

Almost every program I have worked on uses some technqiue to convert enumberated values to strings (and vice-versa). I suspect I have seen a dozen or more different techniques when multi-language translation is factored in. I am curious to what preferences other developers have and any pros/cons they see with those techniques.

I am curious about the actual measured overhead in program performance and size due to exception handling. Ideally this would isolate the effects of multiply-nested try/catch blocks, etc. While I could build some sample apps to measure this, I was wondering if anyone has or can point me to some definitive, quantitative info before I start that effort?

Am about to embark on the process of upgrading our companies development systems from VC 6.0 to Visual Studio .Net C++. Am a bit confused why .Net C++ is only $110 a copy from MS, but .Net Professional is $700. Other than support for C# etc, are there any significant differences? Has anybody else had problems with such a change-over?

I have been programming with c++ since the Cfront "compiler" came out of ATT. I have never found a circumstance where delete this seemed like a correct solution. My impresssion is that it is an artifact of bad design. The fact that the MFC and COM implementation require it is not a surprise ;-) Along the same line, throwing an exception via a pointer is equally dangerous in my book!

I am looking for a class(es) that implement a TV guide style infterface. Not quite like a grid, since all the cells in verious lines start and end on arbitrary boundaries. Anybody seen anything like that?

Does anyone know ofa mechansim to get thread timing information. I am trying to get a better understanding of the percentage of CPU utilization in a multi-threaded app, but on a per-thread basis as opposed to a per function basis. The system APIs provide this info for processes, but I have been unable to get equivalent info for threads. If someone can elighten me, or suggest a technique, I would appreciate it.