История изменений

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это по идее не скомпилиться, там нет перегрузки.

UP: С extern может скомпиляться, ок) Но сомневаюсь что будет работать sizeof(void *) + sizeof(char) != sizeof(int) как правило.

Компоновщику плевать какие там размеры

Я бы не был столь категоричным. В компановщиках давно используют всякие оптимизации типа LTO. И они давно работают сложнее чем просто матчинг имен.

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это по идее не скомпилиться, там нет перегрузки.

UP: С extern может скомпиляться, ок)

Компоновщику плевать какие там размеры

Я бы не был столь категоричным. В компановщиках давно используют всякие оптимизации типа LTO. И они давно работают сложнее чем просто матчинг имен.

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это по идее не скомпилиться, там нет перегрузки.

Компоновщику плевать какие там размеры

Я бы не был столь категоричным. В компановщиках давно используют всякие оптимизации типа LTO. И они давно работают сложнее чем просто матчинг имен.

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это даже не скомпилиться, там нет перегрузки.

Компоновщику плевать какие там размеры

Я бы не был столь категоричным. В компановщиках давно используют всякие оптимизации типа LTO. И они давно работают сложнее чем просто матчинг имен.

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это даже не скомпилиться, там нет перегрузки.

Компоновщику плевать какие там размеры

Я бы не был столь категоричным. В компановщиках давно используют всякие оптимизации типа LTO. И они давео работают сложнее чем просто матчинг имен.

Возможно, я слишком упростил пример). Давай рассмотрим посложнее:

struct A {
  int b;
  void foo() { cout << b; }
};

struct A {
  int b;
  int c;
  void foo() { cout << b << c; }
};

и есть пара вызовов A a; a.foo(). В одной либе и другой соответственно. Как, по твоему мнению, компоновщик должен узнать какую версию foo вызвать? Для компановщика и то и другое будет выглядеть как A::foo(A*) (опять же упрощенно).

прекрасно слинкует функцию int foo(int a) { ... } из одного файла с объявленным и использованным extern void foo(void *p, char c); …

Звучит странно. В плюсах имена параметров являются частью name mangling. Иначе перегрузка бы не работала, от слова совсем. А в Си это даже не скомпилиться, там нет перегрузки.