C / C++ / MFC

George_George wrote:

I understand what means "nasty macro-like behaviours", but I do not think "nasty macro-like behaviours" is similar to my sample in original question?

George_George wrote:

What do you mean, Maxwell?

Not can an unqualified name used in a template
 ever be bound to a local name. Finally, even if a template
 is first used within a class, unqualified names used in the template
 will not be bound to members of that class.
 Ignoring lcoal names is essential to prevent a lot of
 nasty macro-like behavior.
  
section C.18.3.3 Point of Instantiation Binding

template <typename T> 
struct Base {
  int i;
};
template <typename T> 
struct Derived : public Base<T> {
  int get_i() { return i; } // Even if a template is first used within a class, 
                            //  <font color="red">unqualified names</font> used in the template
                            //  will <font color="red">not be bound to members</font> of that class. 
};

George_George wrote:

1. what is a template do you refer to in the sample?

2. what is the class (within a class) do you refer to in the sample?

3. what is the unqualified names do you refer to in the sample?

4. what is the "members of that class" do you refere to in the sample?

Maxwell Chen wrote:

1. You saw the keyword template.

2. A struct is a class with members being public by default.

George_George wrote:

I can not believe when Bjarne said "Even if a template is first used within a class", he means even if a template keyword? is first used within a class? It should be some specific template, right?

Not can an unqualified name used in a template
 ever be bound to a local name. 

Finally, even if a template is first used within a class,
 unqualified names used in the template will
 not be bound to members of that class.

template<classT>
void sort(vector<T>& v)
{
  sort(v.begin(), v.end()); // use standard library sort()
}
class Container{
  vector<int> v; // elements
  //...
public:
  void sort() // sortelements
  {
    sort(v); // invokes sort(vector<int>& ) rather than Container::sort()
  }
  //...
};

Maxwell Chen wrote:

Not can an unqualified name used in a template ever be bound to a local name.

template <typename T> struct Base {
    int f();
};

template <typename T> struct Derived : Base<T> {
    int g() { return f(); };
};

Maxwell Chen wrote:

Finally, even if a template is first used within a class, unqualified names used in the template will not be bound to members of that class.

BadKarma wrote:

Even when there are global variables or function is correctly understand what the programmer wants and does a check the base class first.

BadKarma wrote:

1. Can one write code which breaks this rule? Meaning, can on write code that explicit calls the global function instead of the base function?

#include <iostream>

using namespace std;

static int i = 100;

template <typename T> struct Base {
public:	
	Base (int _i): i (_i)
	{

	}

	int i;
};

template <typename T> struct Derived : public Base<T> {
public:
	Derived (int _i) : Base<T> (_i)
	{
	}
	int get_i() { return ::i; }
};

int main()
{
	Derived<int> d (200);
	cout << d.i << endl; // output 200
	cout << d.get_i() << endl; // output 100
	return 0;
}

George_George wrote:

Sure, we can. Here is the code to prove.


#include <iostream>

using namespace std;

static int i = 100;

template <typename t=""> struct Base {
public:
Base (int _i): i (_i)
{

}

int i;
};

template <typename t=""> struct Derived : public Base<t> {
public:
Derived (int _i) : Base<t> (_i)
{
}
int get_i() { return ::i; }
};

int main()
{
Derived<int> d (200);
cout << d.i << endl; // output 200
cout << d.get_i() << endl; // output 100
return 0;
}

int get_i() { return ::i; }

George_George wrote:

What do you mean this before?

"Even when there are global variables or function is correctly understand what the programmer wants and does a check the base class first."

BadKarma wrote:

the VC compilter correctly choses the i defined in the base class.

namespace N {
   void f(int) { printf("f(int)\n");}
}
 
template <class T> void g(T) {
   N::f('a');   // calls f(char) should call f(int)
}
 
namespace N {
   void f(char) { printf_s("f(char)\n");}
}
 
int main() {
   g('c');
}

template <class T> void g(T t) {
   N::f(t);
}

1>------ Build started: Project: test_template4, Configuration: Debug Win32 ------
1>Compiling...
1>main.cpp
1>d:\visual studio 2008\projects\test_template4\test_template4\main.cpp(20) : error C2065: 'i' : undeclared identifier
1>        d:\visual studio 2008\projects\test_template4\test_template4\main.cpp(20) : while compiling class template member function 'int Derived<T>::get_i(void)'
1>        with
1>        [
1>            T=int
1>        ]
1>        d:\visual studio 2008\projects\test_template4\test_template4\main.cpp(26) : see reference to class template instantiation 'Derived<T>' being compiled
1>        with
1>        [
1>            T=int
1>        ]

#include <iostream>

using namespace std;

template <typename T> struct Base {
public:	
	Base (int _i): i (_i)
	{

	}

	int i;
};

template <typename T> struct Derived : public Base<T> {
public:
	Derived (int _i) : Base<T> (_i)
	{
	}
	int get_i() { return i; }
};


int main()
{
	Derived<int> d (200);
	cout << d.get_i() << endl; // output 200
	return 0;
}

nitin3 wrote:

How to seperate main windows from them extactly as Windows TaskManager does ?