精华内容
下载资源
问答
  • C++重载括号和重载类型探索

    千次阅读 2016-04-19 22:59:02
    //如果仅仅只是重载括号,compile error A()相当于构造A对象吗? cout () ;//强制类型转换 return 0; } D:\programming\C++>g++ TestOperatorQuote.cpp D:\programming\C++>a 123 123 123 345
    #include<iostream>
    using namespace std;
    
    class A{
    	public:
    		int operator ()(){
    			return 123;
    		}
    		operator int(){
    			return 345;
    		}
    };
    void print(A a){
    	cout << a() << endl;
    }
    int main(){
    	A b = A();//直接对象
    	cout << b() << endl; 
    	print(A());//传入对象
    	A a;
    	cout << a() << endl;
    	//cout << A() << endl;//如果仅仅只是重载了括号,compile error A()相当于构造A对象吗?
    	cout << A() << endl;//强制类型转换
    	return 0;
    
    }
    

    D:\programming\C++>g++ TestOperatorQuote.cpp
    
    D:\programming\C++>a
    123
    123
    123
    345

    展开全文
  • c++括号运算符重载

    2020-11-03 18:23:47
    可以将对象加括号运算

    在这里插入图片描述
    可以将对象加括号运算,看起来像构造函数一样,其实不然,一个小坑,日后留意。
    在这里插入图片描述

    展开全文
  • C++operator()(重载括号运算符)

    万次阅读 多人点赞 2019-09-24 22:32:39
    C++语言中有时候需要重载运算符: (),今天我们主要介绍它主要应用的场合。 仿函数 先考虑一个简单的例子:假设有一个vector,你的任务是统计长度小于5的string的个数,如果使用count_if函数的话,你的代码可能...

    在C++语言中有时候需要重载运算符: (),今天我们主要介绍它主要应用的场合。

    仿函数

    先考虑一个简单的例子:假设有一个vector,你的任务是统计长度小于5的string的个数,如果使用count_if函数的话,你的代码可能长成这样:

     bool LengthIsLessThanFive(const string& str) {
          return str.length() < 5;    
     }
     int res = std::count_if(vec.begin(), vec.end(), LengthIsLessThanFive);
    

    其中count_if函数的第三个参数是一个函数指针,返回一个bool类型的值。一般的,如果需要将特定的阈值长度也传入的话,我们可能将函数写成这样:

     bool LenthIsLessThan(const string& str, int len) {
         return str.length()<len;
     }
    

    这个函数看起来比前面一个版本更具有一般性,但是他不能满足count_if函数的参数要求:count_if要求的是unary function(仅带有一个参数)作为它的最后一个参数。所以问题来了,怎么样找到以上两个函数的一个折中的解决方案呢?

    这个问题其实可以归结于一个data flow的问题,要设计这样一个函数,使其能够access这个特定的length值,回顾我们已有的知识,有2种解决方案可以考虑:

    1. 函数的参数:
      这种方法我们已经讨论过了,多个参数不适用于count_if函数;

    2. 全局变量:
      我们可以将长度阈值设置成一个全局变量,代码可能像这样:

        int maxLength;
        bool LengthIsLessThan(const string& str) {
            return str.length() < maxLength;
        }
        int res = std::count_if(vec.begiin(), vec.end(), LengthIsLessThan);
      

    这段代码看似很不错,实则不符合规范,刚重要的是,它不优雅。原因有以下几点要考虑:

    1. 容易出错:
      为什么这么说呢,我们必须先初始化maxLength的值,才能继续接下来的工作,如果我们忘了,则可能无法得到正确答案。此外,变量maxLength和函数LengthIsLessThan之间是没有必然联系的,编译器无法确定在调用该函数前是否将变量初始化,给码农平添负担;
    2. 没有可拓展性:
      如果我们每遇到一个类似的问题就新建一个全局变量,尤其是多人合作写代码时,很容易引起命名空间污染(namespace polution)的问题;当范围域内有多个变量时,我们用到的可能不是我们想要的那个;
    3. 全局变量的问题:
      每当新建一个全局变量,即使是为了coding的便利,我们也要知道我们应该尽可能的少使用全局变量,因为它的cost很高;而且可能暗示你这里有一些待解决的优化方案。

    说了这么多,还是要回到我们原始的那个问题,有什么解决方案呢?答案当然就是这篇文章的主题部分:仿函数。我们的初衷是想设计一个unary function,使其能做binary function的工作,这看起来并不容易,但是仿函数能解决这个问题。

    先来看仿函数的通俗定义:仿函数(functor)又称为函数对象(function object)是一个能行使函数功能的类。仿函数的语法几乎和我们普通的函数调用一样,不过作为仿函数的类,都必须重载operator()运算符,举个例子:

     class Func{
         public:
             void operator() (const string& str) const {
                 cout<<str<<endl;
             }
     };
     Func myFunc;
     myFunc("helloworld!");
     output: helloworld!
    

    仿函数其实是上述解决方案中的第3种方案:成员变量。成员函数可以很自然的访问成员变量:

     class StringAppend{
          public:
              explicit StringAppend(const string& str) : ss(str){}
      
              void operator() (const string& str) const{
                   cout<<str<<' '<<ss<<endl;
              }
          
          private:
             const string ss;  
     };
     
     StringAppend myFunc("is world");
     myFunc("hello");
     output: hellois world
    

    我相信这个例子能让你体会到一点点仿函数的作用了;它既能想普通函数一样传入给定数量的参数,还能存储或者处理更多我们需要的有用信息。

    让我们回到count_if的问题中去,是不是觉得问题变得豁然开朗了?

     class ShorterThan {
         public:
             explicit ShorterThan(int maxLength) : length(maxLength) {}
             bool operator() (const string& str) const {
                 return str.length() < length;
             }
         private:
             const int length;
     };
    
    • count_if(myVector.begin(), myVector.end(), ShorterThan(length)); //直接调用即可

    这里需要注意的是,不要纠结于语法问题:ShorterThan(length)似乎并没有调用operator()函数?其实它调用了,创建了一个临时对象。你也可以自己加一些输出语句看一看。

    类型转换

    C++中可以定义类型转换函数,将类对象转换为其他类型,函数原型为:operator Type()

    • 类型转换函数与转换构造函数具有同等的地位;
    • 类型转换函数使得编译器有能力将对象转化为其他类型;
    • 编译器能够隐式的使用类型转换函数;

    转换为普通数据类型

    	#include <iostream>
    	#include <string>
    	using namespace std;
    	class Test
    	{
    	   
    	public:
    	    Test(int i = 0)
    	    {
    	        mValue = i;
    	    }
    	    int value()
    	    {
    	        return mValue;
    	    }
    	    operator int ()
    	    {
    	        return mValue;
    	    }
    	    
    	private:
    	 	  int mValue;
    	};
    	
    	int main()
    	{   
    	    Test t(100);
    	    int i = t;
    	
    	    cout << "t.value() = " << t.value() << endl;
    	    cout << "i = " << i << endl;
    	
    	    return 0;
    	}
    

    类类型之间的转换

    #include <iostream>
    #include <string>
    
    class Test;
    
    class Value
    {
    public:
    	Value()
    	{
    
    	}
    
    	Value(Test& t) // false
    	// explicit Value(Test& t) // Ok
    	{
    		std::cout << "explicit Value(Test& t)" << std::endl;									    
    	}			
    };
    
    class Test
    {
    	int mValue;
    
    public:
    	Test(int i = 0)
    	{
    		mValue = i;							    
    	}
    
        int value()
    	{
    		return mValue;								    
        }
    
    	operator Value()
    	{
    		Value ret;
    		std::cout << "operator Value()" << std::endl;
    		return ret;											    
    	}					
    };
    
    int main()
    {   
    	Test t(100);
    	Value v = t;
    
    	return 0;				
    }
    

    从输出结果我们可以发现:转换构造函数和类型转换函数发生冲突了,编译器不知道应该调用哪个函数。因此发生了错误。
    当然我们可以使用explicit关键字抑制隐式的转换构造函数,让程序只调用类型转换函数。但是,我们无法抑制隐式的类型转换函数。

    展开全文
  • 伪函数非常的灵活。 在这里用对象实现两个整数... int operator()(int a,int b)//伪函数,operator后面接的是()小括号,就是装载小括号,输入的参数为两个整数,返回值为整型 { return a+b; } }; void test1() {

    伪函数非常的灵活。
    在这里用对象实现两个整数的相加。

    #include<iostream>
    using namespace std;
    
    
    class Myadd
    {
        public:
            int operator()(int a,int b)//伪函数,operator后面接的是()小括号,就是装载小括号,输入的参数为两个整数,返回值为整型
            {
                return a+b;
            }
    };
    
    
    
    void test1()
    {
        Myadd add;//创建对象
        int ret=add(1,2);调用伪函数将返回值赋值给ret
        cout<<ret<<endl;
    }
    
    
    
    
    int main()
    {
        test1();
        return 0;
    }
    
    
    
    
    
    
    展开全文
  • 转自:... C++项目中,经常会遇到使用重载()操作符的地方,请看下面一个例子: #include using namespace std; class Clastype { public: Clastype(int a)
  • C++ 重载括号

    千次阅读 2016-03-30 13:43:20
    c++括号 重载
  • 这里就是想问下,重载二维数组的下标运算符,有什么思路没,初学者能理解的那种…,顺便问下重载括号函数调用运算符的思路,圆括号重载目前完全没思路。如果有大神愿意贴出部分关键源代码,在此再次感谢了
  • C++ 重载函数匹配顺序

    千次阅读 2020-04-10 16:11:09
    待写
  • c++括号运算符可以使用 operator方法来重载 p439
  • c++实现对"[]"和"()"的重载

    万次阅读 多人点赞 2017-08-07 18:21:47
    1. 重载括号  ”[]”在c/c++一般是实现取数组元素的值操作,”[]”内的数值为数组的下标,数组的下标为整数,如ar[0]、ar[7]。现在要实现的功能是重载”[]”使其支持下标是字符串类型的,如ar[“1st”],怎么做...
  • C++括号()操作符的重载自我理解

    千次阅读 2015-04-13 10:50:44
    #include using namespace std; class ClassKZ { public: ClassKZ(int a) { cout } bool operator ()(int b) { cout return true; } }; void main() { ClassKZa(1);
  • c++重载两个中括号[][]

    2017-04-10 05:34:14
    c++重载两个中括号[][],就像二维数组一样使用 直接重在不行,得怎么弄?
  • 重载后的使用方式相当灵活,没有固定写法,什么返回值,传入类型的什么都很灵活。 由于重载后的使用方式非常像函数的调用,因此称为仿函数。 #include<iostream> #include<string> using namespace std...
  • C++优先队列默认是最大堆,所以如果我们要用到最小堆,就需要进行重载来使用。 priority_queue的头文件是<queue>. 1.less和greater,不利用struct进行重载。 priority_queue<int, vector<int>, ...
  • !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  • c++课本p312有关于单目运算符++重载的示例 以前++为例 其代码Time Time::operator++(){ if(++sec>=60){ sec-=60; ++minute; } return *this;}//看到之后非常不解,此程序明明只需要将本对象中的private数据minute和...
  • C++仿函数和()运算符重载

    千次阅读 2018-05-16 08:51:19
    //小括号重载 版本0 void operator()() { cout; } //小括号重载 版本1 void operator()(int h) { cout; } //小括号重载 版本2 void operator()(int h, int m) { cout; } };...
  • 括号操作符重载

    2017-11-12 18:36:00
    //括号里面的参数会被自动当作形参传入   cout  sq(12)  endl;  //144   cout  sq(1,5,3)  endl;  //3   cout  sq(1,3)  endl;  //4   return   0; } 本文转自神ge 51CTO...
  • #include #include #include #include #include using namespace std; using namespace boost::assign;...//用括号赋值?  vector v = (list_of(1),2,3,4,5); BOOST_FOREACH(int x,v) { cout <<
  • c++重载double

    2020-10-02 10:38:07
    //program 13.7.1.cpp 重载double #include <iostream> using namespace std; class Complex/*复数类*/ { double real,imag; public: Complex(double r=0,double i=0):real(r),imag(i) { };//constructor ...
  • C++重载运算符以及operator=的重载

    千次阅读 多人点赞 2019-10-11 14:41:16
    重载运算符 问题引入 int a=10 int b=20 int c=a+b 对于内置数据类型编译器知道如何运算(+) 然后对于自定义类型 People p1+People p2 编译器是处理不了的,因为People类内部没有定义 操作符 +, 在People...
  • 重载括号运算符函数的参数个数没有限制,甚至没有参数都可以。 重载格式: 返回值 operator() ( 表达式表 ) 二、简单示例 #include <iostream> using namespace std; //括号运算符只能重载为类的非...
  • C++ 重载运算符(详)

    千次阅读 2016-11-17 22:59:33
    C++ 重载运算符C 重载运算符 一重载函数 1例程 2备注 二重载运算符 11 二元运算符重载 11 一元运算符重载 111 -- 2备注 3 特殊运算符重载 31 号运算符 32 下标运算符 32 括号运算符 三重载运算符之友元函数 例程 ...
  • C++中方括号[]的作用总结

    万次阅读 多人点赞 2017-09-25 21:12:06
    今天在编程的时候,遇到这样一条语句”delete [] p;”,回想之前使用delete基本上都是采用的”delete p;”的方式,比较好奇这两种...查找相关资料资料之后,决定进一步地把C++中最为常见的符号“[]”的作用进行总结。
  • C++11新特性之大括号初始化

    千次阅读 2019-08-22 21:39:21
    C++11中,vector的初始化和等号赋值都出现了这样的语法 vector<int> nums({1, 2, 3, 4, 5}); vector<int> nums3 = vector({1, 2, 3, 4, 5}); vector<int> nums2; nums2 = {1, 2, 3, 4, 5}; ...
  • T& operator [](int a) T operator [](int a) 上面一个没问题,下面一个就报错,这是为什么呢?这个引用该怎么理解呢?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,461
精华内容 15,384
关键字:

c++重载括号

c++ 订阅