ich habe ein Problem mit Speicherzuweisung, ich benutze den BDS 2006 und habe im folgenden die Klassen zur TWAIN-Ansteuerung von
http://www.neatcpp.com/ und www.allanpetersen.com modifiziert. Der Datentyp CCapValue ist folgendermaßen definiert:

union CCapValue
{
	int type;
	struct twain_array
	{
		pTW_ARRAY m_pValue;
		long m_nItemSize;
	}array;

	struct twain_enumeration
	{
		pTW_ENUMERATION m_pValue;
		long m_nItemSize;
	}enumeration;

	struct twain_onevalue
	{
		pTW_ONEVALUE m_pValue;
	}onevalue;

	struct twain_range
	{
		pTW_RANGE m_pValue;
	}range;
};

wobei pTW_ENUMERATION in twain.h so definiert ist:

/* TWON_ENUMERATION. Container for a collection of values. */
typedef struct {
   TW_UINT16  ItemType;
   TW_UINT32  NumItems;     /* How many items in ItemList                 */
   TW_UINT32  CurrentIndex; /* Current value is in ItemList[CurrentIndex] */
   TW_UINT32  DefaultIndex; /* Powerup value is in ItemList[DefaultIndex] */
   TW_UINT8   ItemList[1];  /* Array of ItemType values starts here       */
} TW_ENUMERATION, FAR * pTW_ENUMERATION;

Ich habe nun folgende Funktion

BOOL CTwain::GetDifferentCapability(TW_CAPABILITY& twCap, CCapValue *CapInfo, TW_UINT16 cap,TW_UINT16 conType)
{
	CapInfo->type = capNone;
	if(GetCapability(twCap,cap))
	{
		 void * pValue = ::GlobalLock(twCap.hContainer);
		 pTW_ENUMERATION pEnum;
		 pTW_ARRAY pArray;
		 long nItemSize;
		 long nSize;
		 switch (twCap.ConType) {
			 case TWON_ARRAY:
				 ...

			case TWON_ENUMERATION:
				{
					pEnum = static_cast<pTW_ENUMERATION>(pValue);
					//CapInfo->enumeration.m_pValue = static_cast<pTW_ENUMERATION>(pValue);
					nItemSize = GetTwainTypeSize(pEnum->ItemType);
					if(nItemSize)
					{
						nSize = sizeof(TW_ENUMERATION) - sizeof(TW_UINT8) + nItemSize * pEnum->NumItems;
						void * pMem = new BYTE[nSize];
						memset(pMem, 0, nSize);
						int aa = sizeof(TW_ENUMERATION);
						int ab = sizeof(TW_UINT8);
						//CapInfo.enumeration.m_pValue = new TW_ENUMERATION;
						memcpy(pMem, pEnum, nSize);
						byte *test = new byte[nSize];
						memcpy (test, pMem, nSize);
						CapInfo->enumeration.m_pValue = static_cast<pTW_ENUMERATION>(pMem);  //(1)
						CapInfo->enumeration.m_nItemSize = nItemSize;
						CapInfo->type = capEnumeration;                                      //(2)
						int testrr = 0;                                                      //(3)   
					}

					break;
				}
			case TWON_ONEVALUE:
                                    ...  
			case TWON_RANGE:
		                  ...
			default:
				return false;
			}
	}
	::GlobalUnlock(twCap.hContainer);
	::GlobalFree(twCap.hContainer);
	return (CapInfo->type != capNone);
}

wobei ich bei ... der Übersichtlichkeit halber den Code entfernt habe, da mein Problem in

case TWON_ENUMERATION

auftritt.

Wenn ich mit dem Debugger durch die Funktion gehe, ist in case TWON_ENUMERATION auch alles ok,

CapInfo->enumeration.m_pValue

erhält in (1) eine Adresse und der Inhalt ist auch ok, wenn ich im Debugger von (2) nach (3) springe, so ändert sich die Adresse und der Inhalt ist nicht mehr definiert.

Hat irgendjemand eine Ahnung, woran das liegen könnte?

Gruss
Lodo2609

union CCapValue
{
    int type;
    struct twain_array { ... };
    struct twain_enumeration { ... };
    ...

Also entweder in type oder in twain_enumeration etwas reinschreiben.
Was soll überhaupt 'type' sein, d.h. woher kommt 'capEnumeration'?

Gruss Lodo2609