为什么只针对重载操作符，而不针对名称相同但作用域不同的函数？
为了理解为什么只针对重载操作符而不针对名称相同但作用域不同的函数，首先需要了解重载操作符和函数作用域的概念。
重载操作符指的是在编程语言中，为了对不同的数据类型进行特定的操作，可以对操作符进行重载，以实现不同的功能。通过重载操作符，我们可以定义自定义的行为，使得操作符对不同的数据类型进行适当的操作。
函数作用域指的是在编程语言中，函数的定义和调用需要在特定的作用域范围内进行。每个函数都有自己的作用域，包括函数的参数、局部变量和函数体内的代码。作用域可以限定函数内部的变量和函数对外部变量的访问。
现在回答为什么只针对重载操作符，而不针对名称相同但作用域不同的函数这个问题。重载操作符是一种特殊的语法结构，允许我们对不同的数据类型进行自定义操作。由于操作符是语言内置的元素，对于操作符的重载，编译器可以通过语法分析和类型推导来判断调用哪个重载版本的操作符函数。因此，对于重载操作符，可以根据不同的数据类型来选择正确的操作符函数。
然而，函数的作用域是在运行时决定的，而不是在编译时。编译器无法通过语法分析和类型推导来确定调用哪个作用域的函数。因此，对于名称相同但作用域不同的函数，编译器无法准确确定调用哪个函数。这样的设计会引入很多歧义和不确定性，使得代码难以理解和维护。为了避免这种混乱，大多数编程语言选择只针对重载操作符进行处理，而不针对名称相同但作用域不同的函数。
总结起来，只针对重载操作符而不针对名称相同但作用域不同的函数，是因为重载操作符是一种特殊的语法结构，编译器可以通过语法分析和类型推导来确定调用哪个重载版本的操作符函数；而函数的作用域是在运行时决定的，编译器无法准确确定调用哪个作用域的函数，容易引起代码歧义和不确定性。
相关·内容
1回答
我把我的宏(很糟糕，让小孩子害怕，比如Google )切换到了作用域枚举。我认为有范围的枚举是很好的。然后我写了这个：
if ((msg.Stamp & RECEIVERS::BROADCAST) != RECEIVERS::BROADCAST)
^^^^^^^^^^^^^^^^^^^^
//do stuff
intellisense给了我一个奇怪的错误，比如：“表达式必须具有整型或未限定范围的枚举”。为什么我不能用限定范围的枚举按位表示？
浏览 1提问于2014-05-02得票数 3
回答已采纳
我正在尝试重载向量的基本算术运算符。这个想法是创建一个计算器，它可以对非常长的数字进行加、减、乘运算(例如，长度为4000)。当我将两个向量相加时，我希望我的程序从两个向量的开头开始循环，将值相加，然后将它们推到第三个向量。我知道我不应该重载std类，或者我可以使用stl和boost来实现这一点，但我的项目不允许这样做。
我的主要问题是我的程序似乎不能识别我的重载操作符。下面是一个代码片段：
从…
//calculator.h
class Calculator {
public:
....
void Solve();
friend std::vector<int> oper
浏览 3提问于2016-09-26得票数 1
下面的简化示例说明了流运算符>>和<<的问题。该示例在GCC10和GCC11中使用C++17标准编译，但在GCC 12.1中没有编译。在GCC 12中，未找到在未命名名称空间中声明的>>和<< ns_f::A运算符。
这是我的第一个问题，为什么运算符>>和<<不在GCC12中？GCC 12发生了什么变化，为什么改变了？
一个可能的解决方案是将操作符声明放入内联朋友函数中的A类中。但我喜欢将操作符隐藏在file.o模块中的版本。
在我的实验中，我发现在未命名的命名空间之后，类Wrapper的移动声明解决了这个问题。这是我的第
浏览 6提问于2022-05-25得票数 -2
回答已采纳
下面这段非常简单的代码无法编译
#include <vector>
#include <string>
namespace Foobar {
struct Test {
std::string f;
std::uint16_t uuid;
};
}
bool operator==(const Foobar::Test& lhs, const Foobar::Test& rhs){
return lhs.f == rhs.f && lhs.uuid == rhs.uuid;
}
浏览 15提问于2018-07-21得票数 14
回答已采纳
描述
我正在重写<< operator以使std::ostream易于在代码中显示对象。在定义要显示的对象类型时，我使用不同的命名空间。
这导致了编译错误。我找到解决办法了。似乎必须在全球范围内声明压倒一切，但我真的不明白为什么。有人能解释一下是什么原因造成的错误吗？
错误
main.cpp:22:38: error: no match for ‘operator<<’ (operand types are ‘std::basic_ostream’ and ‘std::vector’)
std::cout <<"printVecto
浏览 3提问于2021-04-14得票数 2
回答已采纳
让我们考虑一下下面的代码：
struct message
{
uint8_t* data;
size_t length;
};
class device_base
{
// ...
public:
virtual ssize_t exec(uint8_t cmd, const uint8_t* data = nullptr, size_t length = 0);
inline ssize_t exec(uint8_t cmd, const message& msg)
{
return exec(cmd, msg.data, msg.length);
浏览 0提问于2017-01-21得票数 2
回答已采纳
1回答
void f() {}
namespace test
{
void f(int) {}
void g() { f(); } // error in gcc 6.2.0
}
int main()
{
test::g();
}
使用g++ -std=c++1z main.cpp编译它，输出如下：
main.cpp:在函数'void：：g()：main.cpp:9:4: error:函数'void test:: f(int)‘f()；// error中函数’void test：：f(Int)‘f(Int) {}；// main.cpp:5:6:注意:这里声明了v
浏览 1提问于2016-12-29得票数 7
回答已采纳
1回答
我有以下代码：
#include <fstream>
// Removing this namespace (keeping the content) makes it work
namespace baz {
class Bar {
};
}
std::ostream & operator<<(std::ostream & stream, baz::Bar & value) {
return stream;
}
// Removing this namespace (keeping the content) makes it wo
浏览 2提问于2015-12-10得票数 1
回答已采纳
为什么它不选择正确的过载？我知道错误是：
main.cpp:4:7: error: new declaration ‘int f()’
main.cpp:3:6: error: ambiguates old declaration ‘void f()’
void f() {}
int f() { return 0; }
int main() {
void (&x)() = f;
x();
}
浏览 2提问于2013-01-04得票数 2
回答已采纳
例如：
int age;
cin >> age;
cout << "You are " << age << " years old!" << endl;
我们为什么在这里使用"<<“和">>”运算符？他们在干什么呢？我有点理解位转换，但我不明白它是如何工作的。
浏览 3提问于2016-05-25得票数 4
回答已采纳
3回答
成员函数完全阴影空闲函数，在类内使用相同的名称。完全来说，我的意思是，所有同名的自由函数都不考虑过载解析。我能理解为什么要这样做：
void f();
struct S
{
void f();
void g()
{
f(); // calls S::f instead of ::f
}
};
如果函数具有相同的签名，则其唯一的自然特性是变量作用域的工作方式相同。但是为什么要禁止非矛盾的调用，因为自由函数有着如下不同的签名：
void f();
struct S
{
void f(int x);
void g()
{
浏览 5提问于2012-07-27得票数 13
回答已采纳
这是一个从最初的海报制作的例子中衍生出来的问题：。我希望这是有效的要求，我找不到任何关于这个话题的信息。
有人能说出为什么这样写东西是合法的吗？
#include <iostream>
using namespace std;
struct A{
int count = 0;
void operator ++(){count++;};
void operator ++(int){count++;};
void operator =(int){};
};
int main() {
A a;
++a;
a++;
a=5
浏览 4提问于2014-02-03得票数 3
回答已采纳
1回答
假设我们有这个类定义：
class A{
public:
int a;
A(int i): a(i){}
A operator-() const { return A(- a); } # first operator- function
};
A operator-(const A& o) { return A(- o.a); } # second operator- function
现在，在main函数中，如果我编写：
A a1(10);
A a2 = -a1; # Here the first operator-
浏览 1提问于2020-01-24得票数 0
回答已采纳
6回答
我正在阅读的C++0x常见问题，却被这段代码卡住了。考虑以下代码
struct A
{
void f(double)
{
std::cout << "in double" << std::endl;
}
};
struct B : A
{
void f(int)
{
std::cout << "in int" << std::endl;
}
};
int main()
{
A a; a.f(10.10); // as e
浏览 0提问于2009-06-17得票数 7
回答已采纳
1回答
我了解到内部名称隐藏外部名称(因此重载不会跨作用域)，因为名称查找要在类型匹配之前进行。因此，我编写了以下C++代码来执行此规则：
class Base {
public:
virtual void fcn() {}
};
class Derived : public Base {
public:
void fcn(std::string s) {}
};
Base* bp = new Derived;
bp->fcn();
delete bp;
根据隐藏规则，Derived::fcn(std::string)函数应该隐藏Base::fcn()。但上述代码不顾规则正确编
浏览 1提问于2019-02-20得票数 1
回答已采纳
我在这里发现了一些讨论操作符重载和c++中不能重载的操作符的帖子，比如.、::、.*、sizeof等。但我找不到确切的细节或原因，为什么应该避免.*？你们中的几个人可能会投票认为它是重复的，但如果我得到关于我想要的链接的详细信息，我会非常高兴:)
浏览 1提问于2012-08-23得票数 2
回答已采纳
1回答
我来自JavaScript背景，我第一次见到::操作符。我明白它的作用，但我想知道为什么它是必要的。在JavaScript中，这样的内容是完全有效的：
[1, 2, 3].forEach(console.log);
不需要新的操作符--我只是不直接或显式地调用log函数。所以我的问题是，为什么Java不起作用？Java中有什么东西使Class.method不可用(掩盖它？！)
浏览 5提问于2022-10-10得票数 -3
我对C++还是个新手。
通过一些现有的C++代码，我看到了:：，。和使用的->运算符。问题是，它们之间有什么区别，什么时候你会使用其中之一？
我有时会在C#中看到:：运算符，但我总是使用。访问成员，隐式声明作用域。假设这两个是C++中的等价物，我仍然不确定为什么我们使用箭头->运算符，以及为什么它似乎与点互换使用。操作符。
谢谢。
浏览 8提问于2013-12-27得票数 1
6回答
成员函数隐藏自由函数
、、、
void foo(int)
{
}
class X
{
void foo()
{
}
void bar()
{
foo(42);
// error: no matching function for call to 'X::foo(int)'
// note: candidate is:
// note: void X::foo()
// note: candidate expects 0 arguments, 1 provided
浏览 0提问于2012-01-28得票数 10
回答已采纳
为什么斯威夫特在比较双数和整数时表现得如此怪异？
请考虑以下repl/游乐场代码：
12>12.0 //false
13 > 12.0 //true
13.0 > 12 //true
13 >= 12.0 //true
13 <= 12.0 //false
12.0 < 13 //Error: Ambiguous use of operator '<'
12 < 13.0 //Error: Ambiguous use of
浏览 11提问于2022-11-02得票数 3
我正试图理解boost::scoped_ptr的趋同性。让我们定义一个scoped_ptr指针并写入标准输出，以及它指向的值：
#include <boost/scoped_ptr.hpp>
#include <iostream>
int main()
{
boost::scoped_ptr<int> p{new int{1}};
std::cout << p.get() << '\n'; // ok
std::cout << p << '\n'; /
浏览 8提问于2015-01-23得票数 0
回答已采纳
当我试图编译下一个构造时，我得到了一个错误:不能将参数1从“std：：vector<_Ty>”转换为“浮动”，为什么会发生这种情况？
class A
{
public:
virtual int action(float)
{return 5;}
virtual int action(std::vector<float>)
{return 10;}
};
class B : public A
{
public:
int action(float) override
{return 6;}
};
class C : pu
浏览 4提问于2015-10-19得票数 1
回答已采纳
2回答
我得到了一个简单的数组cars，它是Cars类的解析模型
当我这么做
var uniqCars = _.uniq(cars);
它不起作用。uniqCars与cars完全相同。cars的长度是5，uniqCars的长度是5(应该是2)。
然而，当我这样做时：
var uniqCars = _.uniq(cars,
function (c) {
return c.id;
});
它起作用了。我的问题是，为什么对前者不起作用，对后者起作用？为什么我要这么详细？这是Parse还是下划线的问题？
浏览 5提问于2015-04-16得票数 2
回答已采纳
3回答
我正在测试我对C++继承的理解，并阅读了一些示例代码。根据程序输出，在我看来，double add()函数和int add()函数具有不同的作用域，而不是使用参数10.5调用double add()函数，而是从double到int的隐式类型转换(总是被截断)，取而代之的是调用int add()函数。类型转换将解释为什么输出是11 11。
我的问题如下：
重载的继承函数的范围是什么？
如果有的话，从double到int的类型转换何时无效(即会导致编译时错误)？
我可以在哪里读到更多关于C++中继承名称空间/作用域的细微差别的文章？
#include <iostream&
浏览 2提问于2019-12-05得票数 1
回答已采纳
我对C++很陌生，并试图按以下方式编写界面：
template <class T>
class Comparable
{
protected:
Comparable(){};
public:
virtual int compare(const T&&)=0;
int compare(const T& o)
{
return this->compare(std::move(o));
}
};
我这样做是为了使比较方法能够同时处理l/r值。我从可比性中派生出以下类：
浏览 0提问于2017-03-14得票数 3
回答已采纳
伙计们，如果我在dll代码中覆盖全局的new和delete，这会覆盖用户代码new和delete吗？我做了一个测试，结果显示用户new和delete不会受到影响。如果我想用我的sdk new/delete替换用户代码new和delete，该怎么做呢？
模板类的情况是什么？模板类定义包括一些new/delete。用户代码可能会实例化它。然后，它可能会使用user new/delete，对吗？
浏览 1提问于2011-04-27得票数 6
回答已采纳
请考虑以下代码：
template<typename T>
T operator+(const T& lvh, const T& rvh)
{
return lvh;
}
struct enum_container {
enum {
item1 = 1,
item2 = 2,
item3 = item1 + item2
};
};
int main() {
return 0;
}
使用MS VS 2022编译会出现以下错误：
error C2131: expression did n
浏览 4提问于2022-08-30得票数 2
代码：
namespace asd {
class A { };
void f(A &a) { }
}
void f(asd::A &a) { }
int main() {
asd::A instance;
f(instance);
return 0;
}
错误：
D:\>g++ -Wall -std=c++98 -pedantic a.cpp
a.cpp: In function 'int main()':
a.cpp:10:12: error: call of overloaded 'f(asd::A
浏览 3提问于2013-12-04得票数 0
注意，我不是在要求答案。我只是好奇为什么事情会起作用
我需要为用于类分配的打印机模拟器实现一个优先级队列。在查看了internet上的示例之后，我注意到为了正确地排列优先级队列，operator<被重载了。
为什么operator<需要重载？“<”甚至用来作比较的地方在哪里？实现操作符重载是否会改变队列STL的工作方式？
在我看来，这个实现并不直观:为什么operator>没有被重载呢？如何了解operator<需要重载才能使priority_queue正常工作？
浏览 24提问于2009-03-26得票数 3
回答已采纳
9回答
C++重载解决方案
、、、
在下面的示例中，为什么我必须显式地使用b->A::DoSomething()语句，而不只是b->DoSomething()语句
编译器的重载解析不应该知道我说的是哪种方法吗？
我使用的是Microsoft VS 2005。(注意:在这种情况下，使用虚拟不会有什么帮助。)
class A
{
public:
int DoSomething() {return 0;};
};
class B : public A
{
public:
int DoSomething(int x) {return 1;};
};
int main()
{
B* b = ne
浏览 1提问于2008-09-16得票数 41
回答已采纳
4回答
在Java中使用操作符>、<和==能够正确地比较对象吗？我在我的一个对象中实现了Comparable接口。
它可以节省一些时间，而且写得很好。
if (obj1 < obj2) do sth
而不是
if (obj1.compareTo(obj2) < 0) do sth
如果我实现了其他的东西，这是可能的吗?或者它通常不是这样工作的吗？
浏览 5提问于2014-12-10得票数 2
回答已采纳
3回答
前几天，我学到了一些关于C++的新知识；以下内容不起作用：
class ParentClass {
public:
void someFunction() { printf("ParentClass::someFunction()"); }
};
class ChildClass : public ParentClass {
public:
void someFunction(int a) { printf("ChildClass::someFunction(int)"); }
};
int main() {
ChildCl
浏览 4提问于2015-02-18得票数 3
回答已采纳
我正在尝试将operator<<重载为成员函数。如果简单地这样做，它就会起作用：
我的头文件和MyClass.cc文件中的friend ostream& operator<<(ostream& os, const MyClass& myClass);：
ostream& operator<<(ostream& os, const MyClass& myClass)
{
return myClass.print(os);
}
但是，如果我尝试将friend去掉并使其成为成员函数，则它会报错operator&
浏览 3提问于2012-03-22得票数 25
回答已采纳
为什么不使用ttt::focus_pocus()而不使用()呢？规则是什么?为什么在这里起作用？
#include <iostream>
namespace ttt
{
template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>& focus_pocus(std::basic_ostream<CharT, Traits> &os)
{
return os << "focus pocus";
}
};
浏览 2提问于2022-03-14得票数 0
回答已采纳
2回答
我正在为hash_map编写一些哈希函数的例子。如果我使用编译器定义的比较器，我需要在hash_map中定义比较器。我知道使用tr1::unordered_map更好，但在我的应用程序中，重要的是将最小存储桶数量设置得相当大，并定义平均存储桶( bucket_size )--这是一个增长的条件。
因此，我想在一个基类Foo中实现比较器，并在其他散列器中继承它，比如Bar。
class Foo
{
public:
Foo(const SeedParam& dim);
Foo(const Foo& src);
Foo& operator = (con
浏览 0提问于2010-03-11得票数 3
回答已采纳
3回答
我发现操作符重载的C++解析有一个奇怪的行为，我不能解释自己。一个指向描述它的资源的指针就像一个答案一样好。
我有两个翻译单元。在其中一个(称为util.cpp/h)中，我声明并定义了两个运算符(为了提高可读性，我省略了真正的实现，但问题还是会发生)：
// util.h
#ifndef GUARD_UTIL
#define GUARD_UTIL
#include <iostream>
std::istream& operator>>(std::istream& is, const char* str);
std::istream& oper
浏览 4提问于2012-07-06得票数 11
回答已采纳
在将项目从Visual Studio 2010迁移到2017年的过程中，我遇到了一个问题。其中一个项目具有全局静态重载的new/delete运算符，在使用VS2017编译时，它会抛出一个错误，即new/delete运算符不能声明为静态的(它用于在VS2010上编译)。但是静态确保特定于翻译单元的这些过载的新/删除的范围。当不允许更多的静态new/delete操作符时，如何实现这一点。请帮我提一下建议。
浏览 19提问于2020-05-06得票数 1
2回答
void f()
{}
struct A
{
void f()
{}
};
struct B : A
{
B()
{
f(); // A::f() is always called, and ::f is always ignored
}
};
int main()
{
B();
}
作为类B的设计人员，我可能不知道B的基类，即A，有一个成员函数A::f，我只知道::f，而调用::f正是我想要的。
我所期望的是，由于调用f的模糊性，编译器会出现一个错误。但是，编译器总是选择A::f而忽略::f。我觉得这可能是个大陷阱。
我
浏览 0提问于2013-10-26得票数 2
回答已采纳
2回答
阅读堆叠溢出问题，一般的共识似乎是超载不是多态的一部分。
然而，我的OOP讲稿指出：
有四种多态性:参数化、包含性、胁迫性和过载性。
在注释中，它指的是具有不同参数的方法的重载，以及重载操作符，例如，ints和浮点数意义上的+。
维基百科还指出，“使用函数重载的许多语言都支持also多态性。”
因此，我不明白为什么人们会说这不是多态性的一部分，就像我认为的那样；对于一种方法，我们有不同的形式。
有人能详细说明吗？
谢谢。
浏览 4提问于2014-05-31得票数 1
回答已采纳
1回答
最起码的例子：
class A {};
class B : public virtual A {};
class C : public virtual B {};
// define two overloading virtual functions
// no inheritance, so no overriding/hiding in this class
struct visitor1
{
virtual void visit(A& ) {}
virtual void visit(B& ) {}
virtual ~visitor1();
};
浏览 1提问于2018-11-24得票数 1
回答已采纳
为什么我们不能实现getAB() &&和getAB()这两种方法，但是可以实现其中的任何一种？
作品：
代码：
struct Beta {
Beta_ab ab;
Beta_ab && getAB() && { cout << "1"; return move(ab); }
};
int main() {
Beta_ab ab = Beta().getAB();
return 0;
}
作品：
代码：
struct Beta {
Beta_ab ab;
浏览 1提问于2017-06-10得票数 7
回答已采纳
我用Rust编写了一个“计数字符串中的所有字符”函数，但是对值的更新/添加不适用于括号表示法。为什么会这样呢？
有效的办法是：
use std::collections::HashMap;
fn main() {
let myString = "Go ahead and count all my characters";
let mut myMap = HashMap::new();
for ch in myString.chars() {
*myMap.entry(ch).or_insert(0) += 1;
}
}
不起
浏览 0提问于2019-06-13得票数 2
为什么我不能像这样写代码：
int main()
{
std::map<std::string, int> m;
m.iterator it = m.find("five");
//~~~^~~~~
// nor like this:
m::iterator it = m.find("eight");
}
浏览 2提问于2020-07-22得票数 1
回答已采纳
1回答
编译器找不到重载
、、、
最近，我为一些代码处理了一些简单的类型，并重载了它们的插入操作符，这样它们就可以很容易地打印出来。我遇到了一种情况，我真的收到了一千行编译器呕吐。这里有一个简化的版本：
#include <iostream>
#include <sstream>
#include <utility>
#include <string>
namespace ns{
template<typename KEY, typename VALUE>
using KeyValue = std::pair<KEY, VALUE>;
template
浏览 1提问于2020-01-21得票数 1
回答已采纳
我使用的是丢弃的gem，它在加载它的每个模型上都添加了一个作用域with_discarded。为了编写与任何模型一起工作的代码，我在with_discarded中的所有模型上添加了application_record作用域(通过类方法)，这些模型什么也不做，这样它就会在那些模型中被覆盖，其中包括丢弃的gem中的模块。
但是，rails现在会产生一个警告:每次加载覆盖基本方法的类时，都会出现Creating scope :with_discarded. Overwriting existing method User.with_discarded。为确保完整性，实现如下所示：
def sel
浏览 6提问于2022-07-24得票数 1
3回答
不是一个专业的程序员，而是时不时地写程序，最近我听到一个人给我们讲了一些编程技巧，他说有一件事叫做运算符和函数重载的C++特性会损害程序的性能。
然后我做了一些测试，在执行速度方面，我看不出一些程序有函数和运算符重载和没有重载之间的区别，那么函数/运算符重载的真正缺点是什么，如果有的话？
浏览 2提问于2013-01-18得票数 1
3回答
+=和-=运算符到底是做什么的？
或者它们是隐含的，因为它们是按类型定义的？
我广泛地使用了它们，这是语法的一个非常简单的特性，但我从未想过它是如何工作的深度。
是什么导致了这个问题
我可以像这样连接一个字符串值：
var myString = "hello ";
myString += "world";
都很好。但是为什么这不适用于集合呢？
var myCol = new List<string>();
myCol += "hi";
您可能会说：“好吧，您正在尝试添加一个不同的类型，您不能将一个字符串附加到一个不是字符串的类型中”。
浏览 8提问于2016-11-09得票数 42
3回答
C++重载和覆盖
、、、、
此代码生成以下编译错误：
错误:没有调用'C::print(int)‘的匹配函数
你能帮我弄清楚编译器生成错误的过程吗？(为什么它忽略了B类中的函数)
#include <iostream>
using std::cout;
class A {
public:
virtual void print ()
{ cout << "A";}
};
class B : public A {
int x;
virtual void print (int y)
{cout << x+y;}
};
class
浏览 8提问于2017-07-30得票数 6
回答已采纳
5回答
以下代码将帮助我直接向您说明我的问题：
#include<iostream>
class foo {
public:
class bar {
public:
bar(int a) : m_a(a) {}
void say() { std::cout << m_a << std::endl;}
private:
int m_a;
};
};
int main()
{
foo::bar b(3);
b.say();
}
正如您所看到的，为了声明一个类bar的对象，我们使用了类似语法&#
浏览 11提问于2010-09-26得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
