C / C++ / MFC

jobin007007 wrote:

But do you know of anything in Visual Studio 2008 or any other widely used library that can do the above?

#include <windows.h>
class ABC {
  HANDLE m_child;
public:
  static DWORD __stdcall DO(void* p) {
    ((ABC*)p)->DoReally();
  };
  void DoReally() {};
};
void main()
{
  ABC Object[20];
  HANDLE childHandles[20];
  DOWRD childIds[20];
  for (int i = 0; i < 20; i++) {
    childHandles[i] = CreateThread(NULL, 0, Object[i].DO, &Object[i], 0, &childIds[i]);
  }
}

jobin007007 wrote:

unfortunately Visual C++ 2008 has some issues with Boost::threads package

class Updater
{
public:
  static Updater* StartUpdate()
  {
    Updater* u = new Updater();
    HANDLE hThread = (HANDLE)_beginthread(Updater::ThreadProc, 0, (LPVOID)u);
    return u;
  }

  static void ThreadProc(void* lpvUpdater)
  {
    Updater* updater = (Updater*)lpvUpdater;
    updater->DoUpdate();
  }
  void DoUpdate()
  {
    // Do the update
  }
};

#define BOOST_THREAD_DYN_DLL

#include "stdafx.h"

using namespace System;

extern void flibble();

int main(array<System::String ^> ^args)
{
    Console::WriteLine(L"Hello World");
    flibble();
    return 0;
}

#define BOOST_THREAD_DYN_DLL

#include <boost/thread.hpp>

void ThreadFunc()
{
   for(int i=0;i<INT_MAX;++i)
      ;
}

void flibble()
{
   boost::thread t(&ThreadFunc);
   t.join();
}

jobin007007 wrote:

3) What is difference between static and dynamic linkage.

jobin007007 wrote:

1) what do you actually mean? Would you be able to make the meaning clearer?

jobin007007 wrote:

2) Why is Boost statically linking with my library? or is vice versa? what does that actually mean?

jobin007007 wrote:

I am not sure what my C# Project type is.

// Define your class ABC as before - make the DO method <big>public</big>

void MyThreadProc(void* objectAsVoidPtr)
{
  ABC* object = (ABC*)objectAsVoidPtr;
  object->DO();
}

void main()
{
  ABC Object[20];
  for(int i=0;i<20;i++)
    _beginthread(MyThreadProc, 0, (LPVOID)Object+i); //So 20 Threads are created here.
}

#include <iostream>

template<class A, size_t N>
inline size_t ArraySize(const A ( & )[N]) { return N; }

// Determine array size from an array type - 
//  code from <a href="http://heifner.blogspot.com/2008/04/c-array-size-determination-part-2.html">http://heifner.blogspot.com/2008/04/c-array-size-determination-part-2.html</a>
template <typename T>
struct array_info
{
};

template <typename T, size_t N>
struct array_info<T[N]>
{
   typedef T type;
   enum { size = N };
};

int main()
{
   typedef int (MyArray)[120];
   int a[120];
   float b[120];
   std::cout << ArraySize(a) << std::endl;
   std::cout << ArraySize(b) << std::endl;
   std::cout << array_info<MyArray>::size << std::endl;
}

<br />
template<class A, size_t N><br />
inline size_t ArraySize(const A ( & )[N]) <br />
{ <br />
	return N; <br />
}<br />
<br />
int main()<br />
{<br />
	int a[120];<br />
<br />
	std::cout << ArraySize(a) << std::endl;<br />
}<br />

FocusedWolf wrote:

possible that arrays are more efficient

FocusedWolf wrote:

i'm not sure how it works but my guess is that somehow it's magically reading the size from the declaration of the array.

const BYTE key[] = { 12, 34, 4, 5, 36, 23, 765, 34 };

std::vector<BYTE> vKey;
vKey.push_back(12);
  :           :
vKey.push_back(34);

FocusedWolf wrote:

#include iostream; //can't paste the << >> things here
#include string;

#include <iostream>
#include <string>