N>Скомпилируется ли программа? Если да, то что будет напечатано?
Согласно 7.4.3.1, оба метода applicable in expanded form и какого-то лешего второй является better...
Ума не приложу почему между int[] и int[][] в таком же случае компилятор выбрать не сможет, а между T[] и T[][], где T — bounded generic type of enclosing generic class, выбирает второй... И ведь не важно чем будет являться T...
Вроде бы достаточно прозначно, если следовать интрукции
Обе function members являются applicable. Выбор между ними идет с помощью п. 14.4.2.2:
14.4.2.2 Better function member
Given an argument list A with a sequence of argument types {A1, A2, …, AN} and two applicable function
members MP and MQ with parameter types {P1, P2, …, PN} and {Q1, Q2, …, QN, MP},
Здесь, видимо, опечатка? Должно быть {Q1, Q2, ..., QN}?
Впрочем, не важно. У нас function members are applicable in expanded form, обе последовательности типов пустые, поскольку нет аргументов.
after expansion and type argument substitution,is defined to be a better function member than MQ if
• for each argument, the implicit conversion from AX to PX is not worse than the implicit conversion from
AX to QX, and
• for at least one argument, the conversion from AX to PX is better than the conversion from AX to QX.
Поскольку, как уже отмечено, последовательности пустые, то квантор существования не срабатывает, пока tie.
When performing this evaluation, if MP or MQ is applicable only in its expanded form, then PX or QX refers to a
parameter in the expanded form of the parameter list.
Полезный комментарий, но это не наш случай -- аргументов-то нет.
In case the expanded parameter types {P1, P2, …, PN} and {Q1, Q2, …, QN}, are identical,
Вот, это про нас. Одинаковые пустые последовательности.
the following tiebreaking rules are applied to determine the better function member by comparing the given uninstantiated
and unexpanded parameter types {R1, R2, …, RK} and {S1, S2, …, SL} of the function members MP and MQ
Ключевое слово -- uninstantiated and unexpanded. Для нас K = L = 1, R1 = T[], S1 = T[][]
respectively. In this case, the better function member is determined by the following rules:
• If one of MP and MQ is non-generic, but the other is generic, then the non-generic is better.
Не про нас.
• Otherwise, if one of MP and MQ is applicable in its non-expanded form (or has no params array) and the
other is applicable only in its expanded form (and has a params array), then the non-expanded method is
better.
Не про нас.
• Otherwise, if the numbers of parameters K in MP and L in MQ are different, then the method with more
parameters is better.Note that this can only occur if both methods have params arrays and are only
applicable in their expanded forms.
Не про нас.
• Otherwise, the number of parameters K in MP and L in MQ are the same, and if one method has more
specific parameter types, then that method is better.
А это про нас. T[] is more specific than T[][], что видно далее индукцией по построению типа.
The given parameter types {R1, R2, …, RK} are
defined to be more specific than the given parameter types {S1, S2, …, SL} if each given parameter RX is
not less specific than SX, and at least one given parameter, RX is more specific than SX. A type parameter
is less specific than a non-type parameter. Recursively, a constructed type is more specific than another
constructed type (with the same number of type arguments) if at least one type argument is more
specific and no type argument is less specific than the corresponding type argument in the other. An
array type is more specific than another array type (with the same number of dimensions) if the element
type of the first is more specific than the element type of the second.
Итак, T isless specific than T[], откуда T[] is less specific than T[][]. Дальше уже не важно.
• Otherwise, if one member is a lifted operator and the other member is an unlifted operator, then the
unlifted operator is better.
• Otherwise, neither method is better.
Mab>14.4.2.2 Better function member
Mab>Given an argument list A with a sequence of argument types {A1, A2, …, AN} and two applicable function
Mab>members MP and MQ with parameter types {P1, P2, …, PN} and {Q1, Q2, …, QN, MP},
Mab>Здесь, видимо, опечатка? Должно быть {Q1, Q2, ..., QN}?
Здравствуйте, Mab, Вы писали:
Mab>А это про нас. T is more specific than T[], что видно далее индукцией по построению типа.
Я до этого дошёл, но завис на этих правилах , всё равно не понимаю почему T less specific than T[]:
o A type parameter is less specific than a non-type parameter.
o Recursively, a constructed type is more specific than another constructed type (with the same number of type arguments) if at least one type argument is more specific and no type argument is less specific than the corresponding type argument in the other.
o An array type is more specific than another array type (with the same number of dimensions) if the element type of the first is more specific than the element type of the second.
Поясните пожалуйста, какое из правил здесь действует.
Здравствуйте, nikov, Вы писали:
N>Здравствуйте, Mab, Вы писали:
Mab>>
Mab>>14.4.2.2 Better function member
Mab>>Given an argument list A with a sequence of argument types {A1, A2, …, AN} and two applicable function
Mab>>members MP and MQ with parameter types {P1, P2, …, PN} and {Q1, Q2, …, QN, MP},
Mab>>Здесь, видимо, опечатка? Должно быть {Q1, Q2, ..., QN}?
N>В моем тексте все правильно: N>
Ага, понятно. Я на сайте ECMA подсмотрел, видимо они не обновляют стандарт: www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf
N>А анализ совершенно верный!
Здравствуйте, Пельмешко, Вы писали:
П>Я до этого дошёл, но завис на этих правилах , всё равно не понимаю почему T less specific than T[]:
Вроде бы самое первое из списка. T -- это type parameter, T[] таковым не является.
П>
П>o A type parameter is less specific than a non-type parameter.
П>o Recursively, a constructed type is more specific than another constructed type (with the same number of type arguments) if at least one type argument is more specific and no type argument is less specific than the corresponding type argument in the other.
П>o An array type is more specific than another array type (with the same number of dimensions) if the element type of the first is more specific than the element type of the second.
П>Поясните пожалуйста, какое из правил здесь действует.
Здравствуйте, Mab, Вы писали:
Mab>Здравствуйте, Пельмешко, Вы писали: П>>Я до этого дошёл, но завис на этих правилах , всё равно не понимаю почему T less specific than T[]: Mab>Вроде бы самое первое из списка. T -- это type parameter, T[] таковым не является.
Хм, интересно, то есть T остаётся для компилятора как type parameter, даже в constructed type...
Я первое правило сразу же пропустил, думая что оно действует только для generic-методов...
ИМХО это плохое поведение...
Я бы ограничил это правило type parameter'ами от generic-методов, так как там правило имеет смысл и интуитивно...
Но наверное это повлекло бы какие-нить проблемы
Здравствуйте, nikov, Вы писали:
N>Здравствуйте, Пельмешко, Вы писали:
П>>p.s. Ура, nikov вернулся!
N>Есть место, где я появляюсь более регулярно, там тоже можно найти много интересного: http://youtrack.jetbrains.net/issues/RSRP?q=by:nikov
Здравствуйте, nikov, Вы писали:
N>Можно даже вот так сделать
А можно еще и так:
void Main()
{
var c1 = new C<object>();
c1.A(1);
c1.A();
var c2 = new C<int>();
c2.A(1);
c2.A();
}
class C<T>
{
public void A(object a)
{
Console.WriteLine("A(object a)");
}
public void A(T a)
{
Console.WriteLine("A<>("+typeof(T).Name+" a)");
}
public void A(params T[] a)
{
Console.WriteLine("A<>(params "+typeof(T).Name+"[] a)");
}
public void A(params T[][] a)
{
Console.WriteLine("A<>(params "+typeof(T).Name+"[][] a)");
}
}
А вот почему с шаблонными класами все компилится, а так:
void Main()
{
var b= new B();
b.A();
}
class B
{
public void A(params int[] a)
{
Console.WriteLine("A(params int[] a)");
}
public void A(params int[][] a)
{
Console.WriteLine("A(params int[][] a)");
}
}
и так:
void Main()
{
var b= new B();
b.A();
}
class B
{
public void A<T>(params T[] a)
{
Console.WriteLine("A(params int[] a)");
}
public void A<T>(params T[][] a)
{
Console.WriteLine("A(params int[][] a)");
}
}
Здравствуйте, Mab, Вы писали:
Mab>Здесь int[][] не является more specific по сравнению с int[]. Посмотри внимательно правила определения "more specific".
А где можно скачать самую распоследнюю версию стандарта?
Пришла пора заменить занимательную физику Перельмана в туалете на стандарт C#.
Mab>А здесь вообще другая проблема: компилятор не может вывести тип T. Стоит написать b.A<int>(), и все получится.
, всё равно не понимаю почему T less specific than T[]:
