C / C++ / MFC

Saurabh.Garg wrote:

Something is necessary if removing it means that the system it is part of is no longer usable. Removing integrated debugger from Visual Studio does not mean we cannot program anymore, hence it is not necessary. It just means that it will take longer (potentially) to find bugs in the code. Just look at linux, there are no good integrated debugging enviornemnts (comparable to VS) but it hasnt stopped people from creating some really cool software.

Saurabh.Garg wrote:

It just means that it will take longer (potentially) to find bugs in the code.

Saurabh.Garg wrote:

In my opinion, we are just too much used to integrated debuggger.

Rajesh R Subramanian wrote:

In my opinion, I need the debugger and I think that it plays a very crucial role in my daily development activities.

Saurabh.Garg wrote:

I think it is perfectly fine to work in release mode and swtich to debugger only when a bug needs to be fixed.

Vetukuri Raju wrote:

I am getting these errors because the corresponding libraries are not getting linked.

Iain Clarke, Warrior Programmer wrote:

Follow my name, to my articles. One of them should do exactly what you want.

Rajesh R Subramanian wrote:

I was I'm not able to find something like GetThreadCount() the thread pool API.

DWORD GetThreadCount()
{
    THREADENTRY32 stThreadEntry = {0};
    stThreadEntry.dwSize = sizeof( stThreadEntry );
    HANDLE hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
    if( !Thread32First( hSnap, &stThreadEntry ))
    {
        return 0;
    }
    int nCount = 0;
    DWORD dwCurrentProcessId = GetCurrentProcessId();
    do 
    {
        if( dwCurrentProcessId == stThreadEntry.th32OwnerProcessID )
        {
            nCount ++;
        }
    } while (Thread32Next(hSnap, &stThreadEntry ));
    return nCount;
}

Rajesh R Subramanian wrote:

On the other hand, it looks like this is going to return me the number of threads that my application is running

Rajesh R Subramanian wrote:

I want to be able to find the number of threads that specifically belong to the pool. I think I'll need to put in a bit more research.

Naveen wrote:

ya. I thought if the module is small, you know the count of other threads.

Naveen wrote:

BTW where is the option to find out the thread pool's thread count in process explorer?

#include <atlbase.h>
#include <atlcom.h>
// Reference the Excel object model
#import "libid:00020813-0000-0000-C000-000000000046" auto_search no_dual_interfaces rename("DialogBox", "excelDialogBox") rename("RGB", "excelRGB") rename("DocumentProperties", "excelDocumentProperties") rename("SearchPath", "excelSearchPath") rename("CopyFile", "excelCopyFile") rename("ReplaceText", "excelReplaceText")

// Define the AppEvents handler object.

// First define fucntion information for the events we want to handle
_ATL_FUNC_INFO SheetChangeInfo = { CC_CDECL, VT_EMPTY, 2, { VT_DISPATCH, VT_DISPATCH } };
_ATL_FUNC_INFO AfterCalculateInfo = { CC_CDECL, VT_EMPTY, 0, { } };

// And define an event handler object - note that this object just sets a boolean
// variable to true when a handled event is seen
class ExcelAppEventHandler : public IDispEventSimpleImpl<1, ExcelAppEventHandler, &__uuidof(Excel::AppEvents)>
{
public:
   ExcelAppEventHandler(bool& doneFlag) : done_(doneFlag) { done_ = false; }
   // The sink map maps event handler functions to the events they handle
   BEGIN_SINK_MAP(ExcelAppEventHandler)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x0000061c, &ExcelAppEventHandler::SheetChange, &SheetChangeInfo)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x00000a34, &ExcelAppEventHandler::AfterCalculate, &AfterCalculateInfo)
   END_SINK_MAP()

   // Event handling methods. These match the signatures given in the AppEvents
   // definition except for the return type and we've added in the _stdcall
   // calling convention.
   void _stdcall SheetChange(IDispatch *, struct Excel::Range *)
   {
      done_ = true;
   }
   void _stdcall AfterCalculate()
   {
      done_ = true;
   }
private:
   bool& done_;
};

int _tmain(int argc, _TCHAR* argv[])
{
   // Tell the system we're using COM
   CoInitializeEx(0, COINIT_MULTITHREADED);
   {
      //Declare an Excel object pointer
      Excel::_ApplicationPtr xl;
      // And get a reference to the currently running instance of Excel
      if (SUCCEEDED(xl.GetActiveObject(__uuidof(Excel::Application))))
      {
         // Make sure there's at least one workbook
         xl->Workbooks->Add();
         bool done = false;

         // Instantiate the event handler
         ExcelAppEventHandler handler(done);
         // Tell Excel about the handler
         if (SUCCEEDED(handler.DispEventAdvise(xl)))
         {
            // Run a Windows message loop to pump COM messages - this is needed
            // because that's how COM works...
            MSG msg;
            while (!done && GetMessage(&msg, NULL, 0, 0) > 0) {
               TranslateMessage(&msg);
               DispatchMessage(&msg);
            }            
            // Tell Excel we don't want to handle events any more.
            handler.DispEventUnadvise(xl);
         }
      }
   }
   // Tell the system we're done with COM
   CoUninitialize();
   return 0;
}