C / C++ / MFC

Rajkumar R wrote:

how's that possible, do you hacked your domain server policy [^]

CPallini wrote:

I told you it was a CP issue. Now it's working fine without my intervention.

George_George wrote:

According to standard, the code should not compile.

int a = 3;
for(int i = 0, a = 0; i < 2; i++) {
  printf("a = %d \n", a);
}
printf("a = %d \n", a);

a = 0 // The inner a
a = 3 // The outer a

George_George wrote:

1. I think Visual Studio 2008 provides correct result in the sample you provided. Are there anything wrong?

2. Does your sample have anything related to my question?

George_George wrote:

Seems like Visual Studio is wrong. Please look at section 35.19 of,

http://www.parashift.com/c++-faq-lite/templates.html#faq-35.19[^]

1.I think this line of statement matters, agree?

--------------------
the compiler does not look in dependent base classes (like B<t> when looking up nondependent names (like f).
--------------------

George_George wrote:

2. What disadvantage do we have if the code can compile?

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;
}