C / C++ / MFC

kumar sanghvi wrote:

void function(int y,int w)
{
printf("int function");

}

void function(float y,float w)
{
printf("float function");
}

kumar sanghvi wrote:

function(1.2,2.2);

int main()
{
float f1=1.2, f2=2.2;
int n1=22, n2=23;

function(f1, f2); //f1 and f2 are floats, so the compiler will call the float version.
function(n1, n2); //Similarly, the compiler would call the int version.
function((int)f1, (int)f2); //int version would be called.
function((float)n2, (float)n1); //float version would be called
//function(f1, n2); //Ambiguous! If you enable this, the program won't compile!
return 0;
}

a.cpp:16: error: call of overloaded ‘function(double, double)’ is ambiguous
a.cpp:3: note: candidates are: void function(int, int)
a.cpp:9: note:                 void function(float, float)

kumar sanghvi wrote:

int *p;   //With this statement, you just declared a pointer variable (which will point to an integer)
int w=10; //You declared an integer and initialized it. The storage for this variable is on the stack.
p=&w;    //You made the integer pointer you earlier declared, point to the integer that you just created on the stack.

the memory allocation for both w and p will be on stack only ...?

kumar sanghvi wrote:

when it is really useful to allocate memory dynamically using pointer than allocating on the stack..?

kumar sanghvi wrote:

if possible can u explain with example when the dynamic memory allocation is really useful...

Rajesh R Subramanian wrote:

p=&10;

kumar sanghvi wrote:

int* p; //declared pointer to int (statement does nothing)<br />
int w=10; //declares and initializes an int to 10, but it won't exist unless you use it<br />
p=&10; //this is an error, you probably meant p=&w?

harold aptroot wrote:

And I don't guarantee that anything in this post was actually true, use the information at your own risk

thelonesquirrely wrote:

then we were thinking if it was safe to create a lock like this:

...
Lock l (Mutex m);
... // never using m

correct me if I am wrong, but then m is scoped with l. This works if I only want m to exist for l.

#include <iostream>

class Mutex
{
public:
   Mutex() { std::cout << "Mutex::Mutex\n"; }
   ~Mutex() { std::cout << "Mutex::~Mutex\n"; }
};

class Lock
{
public:
   Lock(Mutex& m) : m_(m) { std::cout << "Lock::Lock\n"; }
   ~Lock() { std::cout << "Lock::~Lock\n"; }
private:
   Mutex& m_;
};

int main()
{
   Lock l(Mutex m);
}

thelonesquirrely wrote:

Is there any taboo no-nos to doing the prior method? Some pitfalls I am not seeing?

jiabin_007_love wrote:

However,how many _connection objects and _recordset objects should I use?