C / C++ / MFC

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the EXAMPLE_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// EXAMPLE_API functions as being imported from a DLL, wheras this DLL sees symbols
// defined with this macro as being exported.
#ifdef EXAMPLE_EXPORTS
#define EXAMPLE_API __declspec(dllexport)
#else
#define EXAMPLE_API __declspec(dllimport)
#endif

// This class is exported from the example.dll
class EXAMPLE_API CExample {
public:
	CExample(void);
	// TODO: add your methods here.
};

extern EXAMPLE_API int nExample;

EXAMPLE_API int fnExample(void);

// example.cpp : Defines the entry point for the DLL application.
//

#include "stdafx.h"
#include "example.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}


// This is an example of an exported variable
EXAMPLE_API int nExample=0;

// This is an example of an exported function.
EXAMPLE_API int fnExample(void)
{
	return 42;
}

// This is the constructor of a class that has been exported.
// see example.h for the class definition
CExample::CExample()
{ 
	return; 
}

int *array[SIZE];
for(int i=0;i<SIZE;i++)
    array[i] = new int;

int **array = new int*[SIZE];

int a = 10;
int b = 20;
int c = 30;
// you can point to existing integer buffers
array[0] = &a;
array[1] = &b;

// you can allocate new integers
array[2] = new int;
*array[2] = 50;

// you can allocate an array if integers to be held in this new pointer.
array[3] = new int[10];
array[3][0] = 100;

setVariableA (UINT bitMask)
{
  enum STYLE styleIterator;
  for (enum STYLE styleIterator=FEATURE1; (styleIterator <= FEATURE3) styleIterator++) {
      if (bitMask & styleIterator) {
         // Handle case for feature "styleIterator"
         ...
      }
  }
}

#include <iostreamᡊe9ac73-238b-46be-991d-0f050c37248dusing namespace std;

class MyCtrl
{
public:
	enum ST { enType1 = 0x01, enType2 = 0x02, enType3 = 0x04 };
	void SetVar(int style)
	{
		int tt;
		for(tt = enType1; tt <= enType3; tt = (tt << 1))
		{
			if(style & tt)
				cout << "Type " << tt / 2 + 1 << " implemented\n";
		}
	}
};

void main()
{
	MyCtrl	ctrl;
	ctrl.SetVar(MyCtrl::enType1 | MyCtrl::enType3);
}

#include <iostreamᡊe9ac73-238b-46be-991d-0f050c37248dusing namespace std;

enum ST { enType1 = 0x01, enType2 = 0x02, enType3 = 0x03 };

void SetVar(int style)
{
	int tt;
	for(tt = enType1; tt <= enType3; tt = (tt << 1))
	{
		if(style & tt)
			cout << "Type " << tt / 2 + 1 << " implemented\n";
	}
}

void main()
{
	SetVar(enType1 | enType3);
}

#define FEATURE1  0x00000001  // bit one
#define FEATURE2  0x00000002  // bit two
#define FEATURE3  0x00000004  // bit three
#define FEATURE4  0x00000008  // bit four
#define FEATURE5  0x00000010  // bit five
.
.
.

void SetVariableA (DWORD dwflags = 0);

SetVariableA (FEATURE1 | FEATURE3);

void SetVariableA (DWORD dwFlags)
{
    if (dwFlags & FEATURE1)
    {
        // FEATURE1 flag set, do what has to be done
    }
    if (dwFlags & FEATURE2)
    {
.
.
.