C / C++ / MFC

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>

//We need to define our list structure
typedef struct _List_t{
char *string;
struct _List_t *next;
}List_t;

//We need to define our hash table itself
typedef struct _HashTable_t{
int size;
List_t **table;
}HashTable_t;

HashTable_t *CreateTable(int);
HashTable_t *CreateTable(int size)
{
HashTable_t *NewTable;

//We wil need to alocate memory both for the table structure 
//and the table itself
NewTable=(HashTable_t*)malloc(sizeof(HashTable_t));
NewTable->table=(List_t**)malloc(sizeof(HashTable_t));

//Initially we will need for the table elements to be NULL
for(int i=0;i<size;i++)
 NewTable->table[i]=NULL;
//We also need to set size of the table
NewTable->size=size;
return NewTable;
}
unsigned int hash(HashTable_t *hashtable, char *str)
{
int a,b,p;
unsigned int hashval=0;
for(int i=0;i<<9; i++) 
hashval = str[i] + (hashval << 5) - hashval;  
               
return hashval%hashtable->size;
} 

//We need to define our search function
List_t *search(HashTable_t *hashtable, char *str)
{
List_t *list;
unsigned int hashval=hash(hashtable,str);
for(list=hashtable->table[hashval];list!=NULL;list=list->next)
 if(strcmp(str,list->string)==0)
{
    return list;
}
    return NULL;
}
//We need the insertion function
int insert(HashTable_t *hashtable, char *str)
{
List_t *NewList;
List_t *CurentList;
unsigned int hashval=hash(hashtable,str);

NewList=(List_t*)malloc(sizeof(List_t));

//Is the item already in the list?
CurentList=search(hashtable,str);
//Handling a positive search
if(CurentList !=NULL) return 2;

//Finally the insertion
NewList->string=_strdup(str);
NewList->next=hashtable->table[hashval];
hashtable->table[hashval]=NewList;
return 0;
}

//We'll need to implement 2  clear functions:one for clearing a specific value in the table, and another one to clear up the table itself
void ClearKey(HashTable_t *hashtable,char *str);
void ClearKey(HashTable_t *hashtable,char *str){
	List_t *list,*temp;
	int hashval=hash(hashtable,str);
//We position ourselves on index of the table, because that's where our head of the list is 
	list=hashtable->table[hashval];
	while(list!=NULL){ 
//If we found what we are looking for erase it
	if(list->string=str)
	  temp=list;
	  list=list->next;
	  free(temp);
	                 }
}

void ClearTable(HashTable_t);
void ClearTable(HashTable_t *hashtable)
{
	List_t *list,*temp;
	if(hashtable!=NULL)
	for(int i=0;i<hashtable->size;i++){
		list=hashtable->table[i];
	while(list!=NULL){
		temp=list;
		list=list->next;
		free(temp);   }
	                                  }
	free(hashtable->table);
	free(hashtable);
}

void main()
{
HashTable_t *MyHashTable;
char *s;
int sel,TableSize=12;
MyHashTable=CreateTable(TableSize);
printf("HashTable created!\n");
for(int i=0;i<MyHashTable->size;i++)
printf("%d",MyHashTable->table[i]);


printf("Select an operation\n");
printf("1. Insert   2. Search   3. Erase   Other=Quit\n");
scanf("%c",&sel);
printf("Your selection is:%c",sel);
printf("\nEnter the key:");
s=(char*)malloc(sizeof(10));
scanf("%s",s);
printf("Key is %s",s);
while(sel<5){
	if(sel=1)
		insert(MyHashTable,s);
	else if(sel=2)
		search(MyHashTable,s);
	     else if(sel=3)
              ClearKey(MyHashTable,s);
		      else
		      printf("Invalid Selection");
	         }
getch();
}

First-chance exception at 0x77052374 in HT.exe: 0xC0000005: Access violation reading location 0x00000004.

First-chance exception at 0x7703317f in HT.exe: 0xC0000005: Access violation reading location 0x00000004.
First-chance exception at 0x7707713d in HT.exe: 0xC0000005: Access violation reading location 0x00000014.
First-chance exception at 0x7708ac07 in HT.exe: 0xC0000005: Access violation reading location 0x06b2efe2.
First-chance exception at 0x66a2d914 (msvcr90d.dll) in HT.exe: 0xC0000005: Access violation writing location 0x06b2f010.
The thread 'Win32 Thread' (0x138) has exited with code -1073741510 (0xc000013a).
Unhandled exception at 0x66a2d914 (msvcr90d.dll) in HT.exe: 0xC0000005: Access violation writing location 0x06b2f010.

yu-jian wrote:

...it cose more than 800M memory.

voo doo12 wrote:

I did. But no one seems to know.

voo doo12 wrote:

Can you show me how I could save image(picture) from webbrowser control using MFC?

/*******************************************
 This function cames from MS samples
*******************************************/
int GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
{
   UINT  num = 0;          // number of image encoders
   UINT  size = 0;         // size of the image encoder array in bytes

   ImageCodecInfo* pImageCodecInfo = NULL;

   GetImageEncodersSize(&num, &size);
   if(size == 0)
      return -1;  // Failure

   pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
   if(pImageCodecInfo == NULL)
      return -1;  // Failure

   GetImageEncoders(num, size, pImageCodecInfo);

   for(UINT j = 0; j < num; ++j)
   {
      if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 )
      {
         *pClsid = pImageCodecInfo[j].Clsid;
         free(pImageCodecInfo);
         return j;  // Success
      }    
   }

   free(pImageCodecInfo);
   return -1;  // Failure
}


void CWebBrowserAppView::OnFileSave()
{
	LPDISPATCH pDisp=GetHtmlDocument();

	IHTMLDocument2* pDoc;
	HRESULT hr=0;

        hr=pDisp->QueryInterface(IID_IHTMLDocument2,(void**)&pDoc);
	if(FAILED(hr))
	{
		pDisp->Release();
		AfxMessageBox(L"Sorry dude, cast failed!");
		return;
	}

	IHTMLElementCollection* pImgs;
	hr=pDoc->get_images(&pImgs);
	if(FAILED(hr))
	{
		pDoc->Release();
	        pDisp->Release();
		AfxMessageBox(L"Sorry dude, can't get images list from document!");
		return;
	}


	long length;
	pImgs->get_length(&length);

	IDispatch *pdImg;
        IHTMLImgElement *pImg;

	CLSID jpgClsid;
	GetEncoderClsid(L"image/jpeg", &jpgClsid);



	for(int i=0;i<length;i++)
	{
		_variant_t index = i;
                hr = pImgs->item( index, index, &pdImg);
                if(SUCCEEDED(hr))
		{
			hr= pdImg->QueryInterface( IID_IHTMLImgElement,  (void **) &pImg);

			 if(SUCCEEDED(hr))
			 {
						long width,height;
						pImg->get_width(&width);
						pImg->get_height(&height);

						IHTMLElementRender* pRend;
						hr=pImg->QueryInterface(IID_IHTMLElementRender,(void**)&pRend);
						if(SUCCEEDED(hr))
						{
								Bitmap* pBmp=new Bitmap(width,height,PixelFormat24bppRGB);

								Graphics* pGr=Graphics::FromImage(pBmp);
								HDC gDc=pGr->GetHDC();
								hr=pRend->DrawToDC(gDc);
								pGr->ReleaseHDC(gDc);


								if(SUCCEEDED(hr))
								{
									CString name;
									name.Format(L"%d.jpg",i);
									pBmp->Save(name,&jpgClsid,NULL);
									name.ReleaseBuffer();
								}

								pRend->Release();
								delete pBmp;
						}
						pImg->Release();
				}

			pdImg->Release();
		}

	}

	pImgs->Release();
	pDoc->Release();
	pDisp->Release();

}