小编Zho*_* Ma的帖子

抱歉标题不清楚,如果找到更好的标题,请随时编辑.在正常功能和模板功能之间的优先级中已经深入讨论了相关主题,但我没有找到我的问题的答案.

我的代码是:

template<typename T>
void f(T t){std::cout << "Template 1" << std::endl;} // template 1

template<typename T, typename B>
void f(T t){std::cout << "Template 2" << std::endl;} // template 2

int main () {
   f(1);  // line 1, template 1 will be called
   f<int>(1);  // template 1 will be called
   f<int,int>(1);  // template 2 will be called
}

在第1行调用模板1函数的可能原因是什么？它在规范中是否定义明确？

在第1行,我认为编译器应该给出"模糊过载"错误.

这是我第一次在这里发帖提问.

class Base {
     private:
         int base;
     friend class Question;
};

class Derived : public Base{
    private:
        int super;
};

class Question{
    public:
        void test(Base& base, Derived & derived)
        {
           int value1 =base.base;  // No problem, because Question is a friend class of base
           int value2 =derived.super; // Compile error, because Question is not a friend class of base
           // Question is here
           int value3 =derived.base;  // No Compile error here, but I do not understand why.
        } 
};

问题在课程问题的最后一行中指出.

下面是学习元编程的一个简单示例，它检查目标类型是否包含在可变参数模板参数中。

template<typename... Arguments> // Generic form
struct AnyOf;

template<typename Target, typename First, typename... Arguments>
struct AnyOf<Target, First, Arguments...> {
  constexpr static bool value = std::is_same<Target, First>::value || AnyOf<Target, Arguments...>::value;
};

template<typename Target, typename Last>
struct AnyOf<Target, Last> : std::false_type {
};

template<typename Target>
struct AnyOf<Target, Target> : std::true_type {
};

template<typename Target>
struct AnyOf<Target> : std::false_type {
};

该解决方案似乎按预期工作，实施肯定可以改进。

有一点我不明白，如果模板声明的通用/主要形式被替换为

template<typename Target, typename First, typename... Arguments>
struct AnyOf {
  constexpr static bool value = std::is_same<Target, First>::value || AnyOf<Target, Arguments...>::value;
}; …

代码如下:

struct A {};   

void f (A& a) {std::cout << "No const" << std::endl;} 

void f (const A& a) {std::cout << "const" << std::endl;} 

int main(){
   f(A()); // indicated as line A, output will be "const".
}

问题1):

为什么line A的输出是"const",即使它A()是一个非const对象？

我认为编译器产生的代码相当于:

const A tempA;
f(tempA); 

是对的吗 ？

问题2),如果修改了两个f函数,则更改对值类型的引用

void f (A a) {std::cout << "No const" << std::endl;} 

void f (const A a) {std::cout << "const" << std::endl;}  

以上代码无法编译.编译器给出"函数f的重新定义"错误.我可以理解为什么错误是由编译器发出的,因为它可以转换const A为A反之亦然.因此,无法在编译时决定.是对的吗 ？

我仍然很好奇,它在c ++规范中定义得很好吗？