C++ 为什么typedef会影响函数重载？

我在一个类中有两个函数（请评论问题，而不是编码风格）：

但是，这并不编译。编译器抱怨无法将T*（其中T是字符）转换为size_T（即尝试调用'FUNC#1）。但如果我将上述代码更改为：

// SEGMENT#2 in function erase(size_t pos, size_t n)
iterator begin = m_begin + pos;
iterator end = begin + n;
erase(begin, end); // call FUNC#2

那么编译器就高兴了。我假设

typedef

是一个别名，没有进行类型检查。那么就编译器而言，

SEGMENT#1==SEGMENT#1

？为什么一个编译另一个不编译

---

EDIT:在测试了Oli的代码之后，我将其与我的代码进行了对比，忘记了将

const

添加到

SEGMENT#2

中的迭代器中。除了在这种情况下添加常量没有意义的论点之外，为什么这会产生

T*

的错误而不是

迭代器的错误。如果您想尝试一下，下面是Oli的代码稍作修改：

#include <stdlib.h>

template <typename T>
class myStringClass
{
private:
  T *m_begin;

public:

  typedef T* iterator;

  void erase(size_t pos, size_t n); // FUNC#1
  void erase(iterator first, iterator last); //FUNC#2
};


template <typename T>
void myStringClass<T>::erase(size_t pos, size_t n)
{
  const T* begin = m_begin + pos; // replace with iterator to compile
  const T* end = begin + n; // replace with iterator to compile
  erase(begin, end); // call the overload
}


template <typename T>
void myStringClass<T>::erase(const iterator first, const iterator last)
{
}

int main(void)
{
  myStringClass<char> x;
  x.erase(1,1);
}

#包括
模板
类myStringClass
{
私人：
开始；
公众：
typedef T*迭代器；
无效擦除（大小位置，大小n）；//函数1
无效擦除（先迭代器，后迭代器）；//FUNC#2
};
模板
void myStringClass:：erase（大小\u t位置，大小\u t n）
{
const T*begin=m_begin+pos；//替换为要编译的迭代器
const T*end=begin+n；//替换为要编译的迭代器
擦除（开始，结束）；//调用重载
}
模板
void myStringClass:：erase（首先是常量迭代器，最后是常量迭代器）
{
}
内部主（空）
{
mystringclassx；
x、 擦除（1,1）；
}
以下代码：

不同于：

const T *x;

T *const x;

这实际上与：

const T *x;

T *const x;

它为
const T*
生成错误，而不是为
const迭代器
生成错误。原因是
const迭代器
扩展为
T*const
，而不是
const T*

extern int foo(int i);
extern int bar(int *i);

void baz()
{
   const int x = 5;
   int y = x;
   foo(x); // Perfectly fine
   foo(y); // Also perfectly fine
   bar(&x); // Not fine at all.
   bar(&y); // Perfectly fine.
}

void bouncy()
{
   typedef int my_t;
   typedef int *myptr_t;
   typedef const my_t const_my_t; // const (int) aka const int
   typedef const myptr_t const_myptr_t; // const (int *) aka int * const
}

也许您可以添加您使用的编译器？@Samaursa:请参阅我的更新答案。@Sjoerd：“0”是一个错误的选择，因为它会导致歧义。但是
x.erase（1,1）
可以；几秒钟后看我更新的问题…@Oli：（关于新编辑）我道歉。我总是把事情搞砸。如果使用迭代器将函数更改为接受
const
，这将使代码有效，但它将无法使用
T*
编译，但将使用
iterator
编译。顺便说一句，即使有你提到的无效代码，它仍然可以编译（试试），这也让我感到惊讶。@Samaursa:好的，我又更新了。将来，当你写问题时，请把你的确切的、实际的代码贴出来……我会的。再次表示歉意。为了这个问题，我想把它简化，但下次我会像你一样举个例子。@Samaursa-当你不知道问题是什么时，你可以通过“简化”它，让问题在不经意间消失。如果您知道导致问题的关键因素是什么，您可能已经解决了问题。
T *const x;

extern int foo(int i);
extern int bar(int *i);

void baz()
{
   const int x = 5;
   int y = x;
   foo(x); // Perfectly fine
   foo(y); // Also perfectly fine
   bar(&x); // Not fine at all.
   bar(&y); // Perfectly fine.
}

void bouncy()
{
   typedef int my_t;
   typedef int *myptr_t;
   typedef const my_t const_my_t; // const (int) aka const int
   typedef const myptr_t const_myptr_t; // const (int *) aka int * const
}