Non-type template arguments and inheritance

[danilo.turina]

Hi all,
today I encountered a problem that I'm only able to solve by using
reinterpret_cast (and I'd like to avoid it).

This was my code until yesterday (omitting includes, "using namespace"
and the like):

-----------------------------------------
// ABC Table
struct Table {
Table(const string& name);

string name;
};

Table::Table(const string& name) : name(name) {
cout << name << endl;
}

// Class Customer
struct Customer : public Table {
const int Id;
const int Userlabel;

Customer();
};

Customer::Customer() : Table("Customer"), Id(1), Userlabel(2) {
}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
SchemaBasedIdToLabelMapper();
};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
cout << (void *) this << endl;
C c;
cout << "IdColumn: " << c.*idColumn << endl;
cout << "LabelColumn: " << c.*labelColumn << endl;
}

int main() {
SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;
}
-----------------------------------------

It worked like a charm. No problem at all.

Today, I had to make a change in the class hierarchy so that Customer
would no more inherit directly from Table but, instead, there would be
an intermediate class between the two that had one of the const
members of Customer.

Here is the new code:

-----------------------------------------
// ABC Table
struct Table {
Table(const string& name);

string name;
};

Table::Table(const string& name) : name(name) {
cout << name << endl;
}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {
const int Id;

TableWithId(const string& name, int id);
};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {
}
// Class Customer
struct Customer : public TableWithId {
const int Userlabel;

Customer();
};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {
}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
SchemaBasedIdToLabelMapper();
};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
cout << (void *) this << endl;
C c;
cout << "IdColumn: " << c.*idColumn << endl;
cout << "LabelColumn: " << c.*labelColumn << endl;
}

int main() {
SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;
}
-----------------------------------------

The code above does not compile, the error that I receive is:

# Non-type template arguments may not create temporaries.

The problem (as I understand it) is that &Customer::Id in reality is
&TableWithId::Id that is of type (typeid() told me) "int const
TableWithId::*" and, since the template requires that the passed
parameter is of type "int const Customer::*", a conversion is
required. This conversion is implemented by the compiler using a
temporary and this, of course, cannot be used with a template
definition.

I tried to change the template, but I don't want to be obliged to
specified in which ancestor the field I'm interested in is.

The only way to make that code compile is to change:

SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

to:

SchemaBasedIdToLabelMapper<Customer, reinterpret_cast<const int
Customer::*>(&Customer::Id), &Customer::Userlabelp;

since (for what's my understanding) the reinterpret_cast does not
create a temporary for the cast (since it's not needed...).

The code compiles and runs fine (is this foreseen by the standard?
with another compiler/platform/weather this could break?). Anyway I'm
not so comfortable with reinterpret_cast so I'll be very happy if
there were some other solution to this issue.

Is there a way to solve this problem without using reinterpret_cast?

Ciao,
Danilo

[mlimber]

On Aug 8, 9:35*am, [e-mail] wrote:

* * today I encountered a problem that I'm only able to solve by using
reinterpret_cast (and I'd like to avoid it).

This was my code until yesterday (omitting includes, "using namespace"
and the like):

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class Customer
struct Customer : public Table {
* * const int Id;
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : Table("Customer"), Id(1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

It worked like a charm. No problem at all.

Today, I had to make a change in the class hierarchy so that Customer
would no more inherit directly from Table but, instead, there would be
an intermediate class between the two that had one of the const
members of Customer.

Here is the new code:

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {
* * const int Id;

* * TableWithId(const string& name, int id);

};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {

}

// Class Customer
struct Customer : public TableWithId {
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

The code above does not compile, the error that I receive is:

# Non-type template arguments may not create temporaries.

The problem (as I understand it) is that &Customer::Id in reality is
&TableWithId::Id that is of type (typeid() told me) "int const
TableWithId::*" and, since the template requires that the passed
parameter is of type "int const Customer::*", a conversion is
required. This conversion is implemented by the compiler using a
temporary and this, of course, cannot be used with a template
definition.

I tried to change the template, but I don't want to be obliged to
specified in which ancestor the field I'm interested in is.

The only way to make that code compile is to change:

* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

to:

* * SchemaBasedIdToLabelMapper<Customer, reinterpret_cast<const int
Customer::*>(&Customer::Id), &Customer::Userlabelp;

since (for what's my understanding) the reinterpret_cast does not
create a temporary for the cast (since it's not needed...).

The code compiles and runs fine (is this foreseen by the standard?
with another compiler/platform/weather this could break?). Anyway I'm
not so comfortable with reinterpret_cast so I'll be very happy if
there were some other solution to this issue.

Is there a way to solve this problem without using reinterpret_cast?

Your reinterpret_cast solution is non-standard and does not work with
EDG or MINGW (courtesy of Dinkumware.com) or Comeau's online tests,
and the last is usually the most standard compliant compiler around.
How about duplicating the member in the subclass like this:

// Class Customer
struct Customer : public TableWithId {
const int Userlabel;
const int Id; // Note this line

Customer::Customer()
: TableWithId("Customer", 1)
, Userlabel(2)
, Id(TableWithId::Id) // Note this line
{}
};

Works for me on all the aforementioned compilers and VS2005.

Ciao! --M

[danilo.turina]

On 8 Ago, 19:57, mlimber <[e-mail]:

On Aug 8, 9:35*am, [e-mail] wrote:

* * today I encountered a problem that I'm only able to solve by using
reinterpret_cast(and I'd like to avoid it).

This was my code until yesterday (omitting includes, "using namespace"
and the like):

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class Customer
struct Customer : public Table {
* * const int Id;
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : Table("Customer"), Id(1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

It worked like a charm. No problem at all.

Today, I had to make a change in the class hierarchy so that Customer
would no more inherit directly from Table but, instead, there would be
an intermediate class between the two that had one of the const
members of Customer.

Here is the new code:

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {
* * const int Id;

* * TableWithId(const string& name, int id);

};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {

}

// Class Customer
struct Customer : public TableWithId {
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

The code above does not compile, the error that I receive is:

# Non-type template arguments may not create temporaries.

The problem (as I understand it) is that &Customer::Id in reality is
&TableWithId::Id that is of type (typeid() told me) "int const
TableWithId::*" and, since the template requires that the passed
parameter is of type "int const Customer::*", a conversion is
required. This conversion is implemented by the compiler using a
temporary and this, of course, cannot be used with a template
definition.

I tried to change the template, but I don't want to be obliged to
specified in which ancestor the field I'm interested in is.

The only way to make that code compile is to change:

* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

to:

* * SchemaBasedIdToLabelMapper<Customer,reinterpret_ca st<const int
Customer::*>(&Customer::Id), &Customer::Userlabelp;

since (for what's my understanding) thereinterpret_castdoes not
create a temporary for the cast (since it's not needed...).

The code compiles and runs fine (is this foreseen by the standard?
with another compiler/platform/weather this could break?). Anyway I'm
not so comfortable withreinterpret_castso I'll be very happy if
there were some other solution to this issue.

Is there a way to solve this problem without usingreinterpret_cast?

Your reinterpret_castsolution is non-standard and does not work with
EDG or MINGW (courtesy of Dinkumware.com) or Comeau's online tests,
and the last is usually the most standard compliant compiler around.

I suspected that. Thanks for confirming.

How about duplicating the member in the subclass like this:

*// Class Customer
*struct Customer : public TableWithId {
* * const int Userlabel;
* * const int Id; * * * * * // Note this line

* * Customer::Customer()
* * * * : TableWithId("Customer", 1)
* * * * , Userlabel(2)
* * * * , Id(TableWithId::Id) *// Note this line
* * {}
*};

Works for me on all the aforementioned compilers and VS2005.

This works but it's not a solution.

In the example I posted, both Customer and SchemaBasedIdToLabelMapper
are in the same source file, while in reality they are two classes
that belongs to two different libraries.

Customer is static from my point of view (i.e. I cannot change it),
while I can operate on the template. So any modification to Customer
is not a solution for me.

Anyway, just for the records, up to now I wasn't able to find any
solution to this problem.

>
Ciao! --M

Thanks for trying.
Ciao,
Danilo

[Francesco]

On 27 Ago, 12:31, [e-mail] wrote:

On 8 Ago, 19:57, mlimber <[e-mail]:

On Aug 8, 9:35*am, [e-mail] wrote:

* * today I encountered a problem that I'm only able to solve by using
>reinterpret_cast(and I'd like to avoid it).

This was my code until yesterday (omitting includes, "using namespace"
and the like):

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class Customer
struct Customer : public Table {
* * const int Id;
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : Table("Customer"), Id(1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

It worked like a charm. No problem at all.

Today, I had to make a change in the class hierarchy so that Customer
would no more inherit directly from Table but, instead, there would be
an intermediate class between the two that had one of the const
members of Customer.

Here is the new code:

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {
* * const int Id;

* * TableWithId(const string& name, int id);

};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {

}

// Class Customer
struct Customer : public TableWithId {
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

The code above does not compile, the error that I receive is:

# Non-type template arguments may not create temporaries.

The problem (as I understand it) is that &Customer::Id in reality is
&TableWithId::Id that is of type (typeid() told me) "int const
TableWithId::*" and, since the template requires that the passed
parameter is of type "int const Customer::*", a conversion is
required. This conversion is implemented by the compiler using a
temporary and this, of course, cannot be used with a template
definition.

I tried to change the template, but I don't want to be obliged to
specified in which ancestor the field I'm interested in is.

The only way to make that code compile is to change:

* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

to:

* * SchemaBasedIdToLabelMapper<Customer,reinterpret_ca st<const int
Customer::*>(&Customer::Id), &Customer::Userlabelp;

since (for what's my understanding) thereinterpret_castdoes not
create a temporary for the cast (since it's not needed...).

The code compiles and runs fine (is this foreseen by the standard?
with another compiler/platform/weather this could break?). Anyway I'm
not so comfortable withreinterpret_castso I'll be very happy if
there were some other solution to this issue.

Is there a way to solve this problem without usingreinterpret_cast?

Your reinterpret_castsolution is non-standard and does not work with
EDG or MINGW (courtesy of Dinkumware.com) or Comeau's online tests,
and the last is usually the most standard compliant compiler around.

I suspected that. Thanks for confirming.

How about duplicating the member in the subclass like this:

*// Class Customer
*struct Customer : public TableWithId {
* * const int Userlabel;
* * const int Id; * * * * * // Note this line

* * Customer::Customer()
* * * * : TableWithId("Customer", 1)
* * * * , Userlabel(2)
* * * * , Id(TableWithId::Id) *// Note this line
* * {}
*};

Works for me on all the aforementioned compilers and VS2005.

This works but it's not a solution.

In the example I posted, both Customer and SchemaBasedIdToLabelMapper
are in the same source file, while in reality they are two classes
that belongs to two different libraries.

Customer is static from my point of view (i.e. I cannot change it),
while I can operate on the template. So any modification to Customer
is not a solution for me.

Anyway, just for the records, up to now I wasn't able to find any
solution to this problem.

Ciao! --M

Thanks for trying.
Ciao,
* * * * * * Danilo- Nascondi testo citato

- Mostra testo citato -

Hi,
interesting... You can try tagging the base class.
The following compiles.
Hope it helps a little.
Bye,
Francesco

#include <iostream>
using namespace std;
// ABC Table
struct Table {
Table(const string& name);
string name;

};
Table::Table(const string& name) : name(name) {
cout << name << endl;
}
// Class TableWithId (intermediate class)
struct TableWithId : public Table {

/*********************/
typedef TableWithId TableWithIDTag;
/*********************/
const int Id;

TableWithId(const string& name, int id);

};
TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {
}
// Class Customer
struct Customer : public TableWithId {
const int Userlabel;

Customer();

};
Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {
}
// Class SchemaBasedIdToLabelMapper
template<class C, const int C::TableWithId::* idColumn, const int C::*
labelColumn>
class SchemaBasedIdToLabelMapper {
public:
SchemaBasedIdToLabelMapper();
};
template<class C, const int C::TableWithId::* idColumn, const int C::*
labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
cout << (void *) this << endl;
C c;
cout << "IdColumn: " << c.*idColumn << endl;
cout << "LabelColumn: " << c.*labelColumn << endl;
}
int main() {
SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

}

//END CODE

[Francesco]

On 27 Ago, 13:36, Francesco <[e-mail]:

On 27 Ago, 12:31, [e-mail] wrote:

On 8 Ago, 19:57, mlimber <[e-mail]:

On Aug 8, 9:35*am, [e-mail] wrote:

* * today I encountered a problem that I'm only able to solve by using
reinterpret_cast(and I'd like to avoid it).

This was my code until yesterday (omitting includes, "using namespace"
and the like):

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class Customer
struct Customer : public Table {
* * const int Id;
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : Table("Customer"), Id(1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

It worked like a charm. No problem at all.

Today, I had to make a change in the class hierarchy so that Customer
would no more inherit directly from Table but, instead, there wouldbe
an intermediate class between the two that had one of the const
members of Customer.

Here is the new code:

-----------------------------------------
// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {
* * const int Id;

* * TableWithId(const string& name, int id);

};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {

}

// Class Customer
struct Customer : public TableWithId {
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::* idColumn, const int C::* labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::* idColumn, const int C::* labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;}

-----------------------------------------

The code above does not compile, the error that I receive is:

# Non-type template arguments may not create temporaries.

The problem (as I understand it) is that &Customer::Id in reality is
&TableWithId::Id that is of type (typeid() told me) "int const
TableWithId::*" and, since the template requires that the passed
parameter is of type "int const Customer::*", a conversion is
required. This conversion is implemented by the compiler using a
temporary and this, of course, cannot be used with a template
definition.

I tried to change the template, but I don't want to be obliged to
specified in which ancestor the field I'm interested in is.

The only way to make that code compile is to change:

* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

to:

* * SchemaBasedIdToLabelMapper<Customer,reinterpret_ca st<const int
Customer::*>(&Customer::Id), &Customer::Userlabelp;

since (for what's my understanding) thereinterpret_castdoes not
create a temporary for the cast (since it's not needed...).

The code compiles and runs fine (is this foreseen by the standard?
with another compiler/platform/weather this could break?). Anyway I'm
not so comfortable withreinterpret_castso I'll be very happy if
there were some other solution to this issue.

Is there a way to solve this problem without usingreinterpret_cast?

Your reinterpret_castsolution is non-standard and does not work with
EDG or MINGW (courtesy of Dinkumware.com) or Comeau's online tests,
and the last is usually the most standard compliant compiler around.

I suspected that. Thanks for confirming.

How about duplicating the member in the subclass like this:

*// Class Customer
*struct Customer : public TableWithId {
* * const int Userlabel;
* * const int Id; * * * * * // Note this line

* * Customer::Customer()
* * * * : TableWithId("Customer", 1)
* * * * , Userlabel(2)
* * * * , Id(TableWithId::Id) *// Note this line
* * {}
*};

Works for me on all the aforementioned compilers and VS2005.

This works but it's not a solution.

In the example I posted, both Customer and SchemaBasedIdToLabelMapper
are in the same source file, while in reality they are two classes
that belongs to two different libraries.

Customer is static from my point of view (i.e. I cannot change it),
while I can operate on the template. So any modification to Customer
is not a solution for me.

Anyway, just for the records, up to now I wasn't able to find any
solution to this problem.

Ciao! --M

Thanks for trying.
Ciao,
* * * * * * Danilo- Nascondi testo citato

- Mostra testo citato -

Hi,
interesting... You can try tagging the base class.
The following compiles.
Hope it helps a little.
Bye,
Francesco

#include <iostream>
using namespace std;

// ABC Table
struct Table {
* * Table(const string& name);

* * string name;

};

Table::Table(const string& name) : name(name) {
* * cout << name << endl;

}

// Class TableWithId (intermediate class)
struct TableWithId : public Table {

* * * * /*********************/
* * * * typedef TableWithId TableWithIDTag;
* * * * /*********************/
* * const int Id;

* * TableWithId(const string& name, int id);

};

TableWithId::TableWithId(const string& name, int id) : Table(name),
Id(id) {

}

// Class Customer
struct Customer : public TableWithId {
* * const int Userlabel;

* * Customer();

};

Customer::Customer() : TableWithId("Customer", 1), Userlabel(2) {

}

// Class SchemaBasedIdToLabelMapper
template<class C, const int C::TableWithId::* idColumn, const int C::*
labelColumn>
class SchemaBasedIdToLabelMapper {
public:
* * SchemaBasedIdToLabelMapper();

};

template<class C, const int C::TableWithId::* idColumn, const int C::*
labelColumn>
SchemaBasedIdToLabelMapper<C, idColumn,
labelColumn>::SchemaBasedIdToLabelMapper() {
* * cout << (void *) this << endl;
* * C c;
* * cout << "IdColumn: " << c.*idColumn << endl;
* * cout << "LabelColumn: " << c.*labelColumn << endl;

}

int main() {
* * SchemaBasedIdToLabelMapper<Customer, &Customer::Id,
&Customer::Userlabelp;

}

//END CODE- Nascondi testo citato

- Mostra testo citato -

SOrry, I've posted in a rush. The tagging it's useless and I actually
mistyped it.
What I meant is:
struct A
{
int mNumb;
};
struct B : A
{
};

struct C : B
{};
template< typename T, int T::A::* KPtr >
struct D
{};
int main()
{
D< C, &C::mNumb > obj;
}