C / C++ / MFC

Iain Clarke, Warrior Programmer wrote:

Are you both in the same class?

if(GetKeyState(VK_CONTROL) && (pMsg->wParam == 0x43))
{
                    CTest obj;
                    obj.DoModal();
                    return TRUE; // this message need not be dispatched.
}

dplong wrote:

I'm thinking I need to overload the == operator. I tried that but ran into even more problems.

#include <iostream>
#include <assert.h>

using namespace std;

class Name
{
public:
	Name(const char* t_) : t(t_) { }
	Name(const string& t_) : t(t_) { }
	Name() { }
	Name(const Name & t_) : t(t_.t) { }
	Name & operator=(const string & rhs) { t = rhs; return *this; }
	operator const string & () const { return t; }
	operator string & () { return t; }
private:
	string t;
};
bool operator==(const Name& left, const Name& right) { return string(left)==string(right); }

int main()
{
	Name n1 = "bananas", n2 = "bananas";
	assert(n1 == n2);	// Couldn't deduce template arg for string from Name
	assert(n1 == "bananas");	// No operator found for LH operand of type Name
} 

<div class="ForumSig">Java, Basic, who cares - it's all a bunch of tree-hugging hippy cr*p</div>

#include <string>
#include <assert.h>

using namespace std;

class Name
{
public:
	Name() { }
	Name(const string & t_) : t(t_) { }
	Name(const char * t_) : t(t_) { }
	Name & operator=(const string & rhs) { t = rhs; return *this; }
	Name & operator=(const char * rhs) { t = rhs; return *this; }
	friend bool operator==(const Name & lhs, const Name & rhs) { return lhs.t == rhs.t; }
	operator const string & () const { return t; }
	operator string & () { return t; }
private:
	string t;
};

int main()
{
	char arr[] = "bananas";
	char *arrP = arr;
	string s = "oranges";
	Name nn1 = s;
	Name n0 = string("apples");
	n0 = s;
	n0 = arr;
	n0 = arrP;
	nn1 = n0;
	Name nn2 = Name(nn1);
	Name n1 = "bananas", n2 = "bananas";
	assert(n1 == n2);
	assert(n1 == string("bananas"));
	assert(n1 == arr);
	assert(n1 == arrP);
	assert(n1 == "bananas");
}

template <class T, class D> class IdTemplate {
public:
	IdTemplate() { }
	IdTemplate(const T t_) : t(t_) { }
	IdTemplate & operator=(const T & rhs) { t = rhs; return *this; }
	friend bool operator==(const IdTemplate & lhs, const IdTemplate & rhs) { return lhs.t == rhs.t; }
	operator T & () { return t; }
	operator const T & () const { return t; }
private:
	T t;
};

Computafreak wrote:

The only other possibility that I can think of is that C programmers dislike excessive typing

Computafreak wrote:

Is this the reason why, or is there a technical constraint on method name length?