C / C++ / MFC

maxMESA wrote:

My question is how can i load this dll in my activex. I am using LoadLibrary(x.dll) and it searches for dll in windows/system32 folder.

std::string GetThisModulesFileName()
{
   HMODULE hMod;
   char path[MAX_PATH];
   GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, reinterpret_cast<lpcstr>(&GetThisModulesFileName), &hMod);
   GetModuleFileNameA(hMod, path, MAX_PATH);
   return std::string(path);
}</lpcstr>

sharion wrote:

About the result, one explanation is p in function GetMemory is only a copy of variable str. This explanation may be right but it seems that it contradicts pass by reference. Now that passing by reference, where is the copy come from. And operations done to variable p is equal to operations to str,why str is NULL finally.

void GetMemory(char** p)
	{
		*p =  new char[100];
	}
int main()
{
   char* str = NULL;
   GetMemory(&str);
   /* */
}

void GetMemory(char*& p)
	{
		p =  new char[100];
	}
int main()
{
   char* str = NULL;
   GetMemory(str);
   /* */
}

Stuart Dootson wrote:

When you pass a pointer, the thing that is pointed at is passed by reference.

void GetMemory(char* p)
{
    p =  new char[100];
    *(p + 10) = 'a'; /* following comment is true or not?*/
                     /* operate to the memory block 
                        that you called passed by reference
                     */
}
int main()
{
   char* str = NULL; 
   GetMemory(str);
   /* */}

char* str = NULL;   // str is a char pointer, set to NULL
GetMemory(str);
     void GetMemory(char* p)  // p is a char pointer set to NULL
     p =  new char[100];      // the old p is overwritten by a new pointer, pointing to a 100 byte buffer
     *(p + 10) = 'a';         // the new p is used to write some into that buffer
     return;
... // back from GetMemory    // str has never been changed

void GetMemory(char** p)    // accept pointer to pointer to char
{
    p =  new char[100];
}
int main()
{
   char* str = NULL; 
   GetMemory(&str);   // pass the address of str (=pointer to pointer)
   // str will have changed now

sharion wrote:

*(p + 10) = 'a'; /* following comment is true or not?*/
/* operate to the memory block
that you called passed by reference
*/

p =  new char[100];

sharion wrote:

We believe str is still NULL, where I have mistaken?

sharion wrote:

Based on experience previous, I take it for granted that whatever you have done to p have the same effect to str. That is passing by reference what I previously thought

int Double(int x)
{
   return x + x;
}

int Double(int *pX)
{
   return (*pX) + (*pX);
}

int StringLength(char* s)
{
   int length = 0;
   while (*(s + length) != 0)
      ++length;
}

Luc Pattyn wrote:

Is it still in active use?

Luc Pattyn wrote:

is there an ADA#?

Luc Pattyn wrote:

should we have a forum on it?

void GetMemory(char* p)
	{
		if(p != NULL)
		{
			delete []p;
			p = NULL;
		}
		if(p == NULL)
		{
			p =  new char[1000];
			*(p+10) = 'a';
		}
	}
int main()
{
char* str = NULL;
str = new char[100];
GetMemory(str);
/* */
}

sharion wrote:

Above code snippet indicates that before and after GetMemory(str);point str is being revised.I have no idea why such happens.

int main()
{
   char* str = NULL;
   str = new char[100];
   std::cout << (int)str <<std::endl;
   GetMemory(str);
   std::cout << (int)str <<std::endl;
/* */
}

Stuart Dootson wrote:

Of course, the memory that str points at is no longer allocated, so you don't want to be using str after the GetMemory call!

sharion wrote:

The value of point str is changed when second it is allocated memory. Do you agree?

sharion wrote:

Actually, str is allocated successfully after GetMemory.When you count the memory size of str between memory allocated two times you can draw this conclusion.

int main()
{
char* str = NULL; // str is assigned the value NULL
str = new char[100]; // str is assigned a value that points to allocated memory
GetMemory(str); // The value of str is COPIED and we call GetMemory
        void GetMemory(char* p) // The parameter p is now a COPY of str
	{
		if(p != NULL) // p is not NULL, so we execute the if statement's body
		{
			delete []p; // delete p. This does not alter the VALUE of p, but it deallocates the memory pointed to by both p AND str.
			p = NULL; // Assign NULL to p. This DOES NOT ALTER THE VALUE OF str.
		}
		if(p == NULL) // p is now NULL, so we execute the if statement's body
		{
			p =  new char[1000]; // Allocate memory and assign its address to p. WE DO NOT ASSIGN THE VALUE TO str. str DOES NOT CHANGE.
			*(p+10) = 'a'; // Set a value within the allocated block of memory
		}
	} // Return to main, DISCARDING p

// We're now back in main. The value of str HAS NOT CHANGED. It now points to an unallocated area in memory
} // End

str = new char[100]; 
int n1= (int)strlen((const char*)str);
GetMemory(str);
int n2= (int)strlen((const char*)str);

sharion wrote:

The first fact,you will find the value of *(str+10) is equal to 'a'.

#include <iostream>

void GetMemory(char* p)
	{
		if(p != NULL)
		{
			delete []p;
			p = NULL;
		}
		if(p == NULL)
		{
			p =  new char[1000];
			*(p+10) = 'a';
		}
	}
int main()
{
char* str = NULL;
str = new char[100];
char* str2 = new char[100];
GetMemory(str);
/* */
}