C++ <四>

最新推荐文章于 2024-08-06 16:24:59 发布
最新推荐文章于 2024-08-06 16:24:59 发布
阅读量85 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/sdluReaLo/archive/2013/03/08/2949874.html
版权

//运算符函数， 重载。

#include<iostream>

using namespace std;

 

class A{

int data;

public:

       A(int d=0):data(d){

       }

       void show(){

       cout<<"data1="<<data<<endl;

       }

       //friend A operator-(const A& a1,const A& a2);//授权，声明在类的内部声明，声明可以和定义写在一起。

   A operator-(const A& o)

   {

          cout<<"相信我，没错。";

          int dif=data-o.data;

          return A(dif);

   }

 

};

 

// A operator-(const A& a1,const A& a2){//友元不是成员，其中没有this。没有当前对象

// cout<<"相信我，没错。"<<endl;

// int sum=a1.data-a2.data;//一般用引用而不是复制一份。

// return A(sum);//初始化：A a1=obj1;  A  a2(obj2);

//}

 

 int main()

 {

        A a1(80),a2(50);

        A a3,a4;

        // a3= operator-(a1,a2);//可以使用operator运算符作为函数名

        //a3.show();

        //a4=a1-a2;//这种类型的函数可以直接写成运算符的形式

        //a4.show();//更像数学上的式子

         a3=a1.operator-(a2);

         a3.show();

         a4=a1-a2;

         a4.show();

 }

//运算符重载就是自己写运算符函数，来规定也能算符如何工作。

*/

 

/*

//写一个分数相乘的运算符函数。

#include<iostream>

using namespace std;

 

class Fenshu{

  int fz;

  int fm;

public:

       Fenshu(int fz=0,int fm=1):fz(fz),fm(fm){}

       friend  Fenshu operator *( const Fenshu& a1,const Fenshu& a2);

    //友元函数不是成员函数。不能继承；

       friend ostream& operator<< (ostream& os,const Fenshu& f)

       {

    os<<f.fz<<'/'<<f.fm;

       return os;

       }

       friend istream& operator>>(istream& is,Fenshu &f)

       {

              char c;

              is>>f.fz>>c>>f.fm;

              return is;//变量

       }

};

   Fenshu operator *( const Fenshu& a1,const Fenshu& a2)

       {

              int zo=a1.fz*a2.fz;

              int mo=a1.fm*a2.fm;

              return Fenshu(zo,mo);

       }

  

int main()

{

       //int a,b;

       //cin>>a>>b;//自定义<<操作符。

       Fenshu a1(2,3);

       Fenshu a2(4,5);

       Fenshu a3;

       a3=a1*a2;

       cout<<a3<<endl;

       Fenshu f1,f2;

       cin>>f1>>f2;

       cout<<f1*f2<<endl;

}

*/

 

/*

#include<iostream>

using namespace std;

 

 

class  A{

       int data;

public:

       A(int d=0):data(d){}

       friend ostream& operator<<(ostream& os,const A&a)

       {

              os<<a.data;

              return os;

       }

       friend istream&  operator>>(istream & is,A &a)

       {

              is>>a.data;

              return is;

       }

       friend A& operator++(A& a)

       {

              a.data+=10;

              return a;

       }

       A& operator--()

       {

              data-=1;

              return *this;

       }

       operator int ()//自动转换类型

       {

              return data;

       }

       operator bool()

       {

              return data!=0;

       }

       operator char()

       {

              return (char)data;

       }

 

 

};

int main()

 

{

       A a(100);//至少有一个操作数是自定义类型的

       cout<<(++a)<<endl;

       cout<<(--a)<<endl;// a--/a++  可看成双目运算符

       A c(65),c2(290);

       cout<<"c="<<(char)c<<endl;

       int d=c2;

       if(c2)

              cout<<"good"<<endl;

       else

              cout<<"bad"<endl;

              */

//对自定义类型的对象，使用运算符时总是调用相应运算符函数。

             

//强制类型能够转换   类型（数据）  不需要写返回类型 operator 类型（）

 //单目运算符不能重载。

// =，()，[]，->，->*  ，类型转换只能利用成员

 

/* 运算符的重载：

双目： 友元形式：  返回类型 operator X（形参1，形参2）

        成员形式：  返回类型 operator  X(形参）

              单目：

              友元   返回  operator x(形参）

                     返回  operator X()

                        输入、输出只能以友元函数

 作业： 复数类  Complex  构造函数： 实部，虚部，重载运算符： +，-，》》，《《，

 类型转换 （double)   实部平方+虚部平方 再sqrt ，

 ~用来交换实部和虚部

*/

/*

#include<iostream>

#include<math.h>

using namespace std;

class Complex{

       int as;

       int ax;

public:

       Complex(int a=0,int b=0):as(a),ax(b){}

       Complex& operator+(const Complex& f)

       {

              return Complex(as+f.as,ax+f.ax);

       }

       Complex& operator-(const Complex& f)

       {

              return Complex(as-f.as,ax-f.ax);

       }

       friend ostream& operator<<(ostream & os,Complex f)//输入输出只能用友元形式来实现运算符的重载；

       {

              cout<<f.as<<"+j"<<f.ax;

           return os;

       }

       friend istream& operator >>(istream& is,Complex f)

       {

              char c1,c2;

              if(f.ax>=0)

              cin>>f.as>>c1>>c2>>f.ax;

              else if(f.ax<0)

              cin>>f.as>>c1>>f.ax;

              return is;

       }

       operator double()

       {

              return (double)sqrt(ax*ax+as*as);

       }

       Complex& operator~()

       {

       //     int x;

       //     x=as;

       //     as=ax;

       //     ax=x;

        swap(as,ax);

        return Complex(as,ax);

       }

};

 

int main()

{

       Complex A(2,1);

       Complex B(3,4);

       cout<<A<<endl;

       cout<<A<<"+"<<B<<'='<<A+B<<endl;

       cout<<~A<<","<<~B<<endl;

}

*/

//-----------------------day_12_am 做好平凡的事情----------------------

// 【day12_am】

//回顾： 一. 拷贝构造函数：有创建对象的时候调用其的参数形式来

//决定调用哪一个拷贝构造函数，A(const A&0)， 默认构造函数回绝

//形参对象的类容全部复制一份，函数语句块， 执行函数中的东西。

// 运算符的重载： 双目，单目，成员形式（单形参），友元形式（双形参）；

//特殊的运算符：>>,<<只能运用友元形式；后++，后--；类型转换：不写返回类型

// 运算符重载的作用是：更适合人们的使用习惯， 让程序更加清晰；

// 重载的条件为： 至少有一个操作数为自定义类型；运算符重载也能继承；

/*

#include<iostream>

using namespace std;

//尽力而为，对个人的最大收获；定位很重要， 确定可实现的位置。

//踏实就好，理解，理解

// 把平凡的事情做好了便不再平凡；

//

class A{

public:

       operator int(){

              cout<<"[int]";

              return 100;

       }

};

int main()

{

       A obj;

       int n=(int)obj;//这个时候有输出【int】

       cout<<"n="<<n<<endl;

       cout<<"obj="<<obj<<endl;

}

*/

 

// I/o， I： 控制台-c，文件-f； O： （C、f控制台完全统一的）

//cout/fout

// O：输出【写出】，向屏幕【控制台】【写】送出数据，向文件写

//I：输入【读入】，从键盘【控制台】【读】、从文件读

// 数据的传输，stream  全部有关I/O的声明都在<iostream>头文件中；

//cin 键盘  标准输入设备

//cout屏幕  标准输出对象

// 数据流【stream】可以改向，缓冲；输出<—满/清-> 显示

//输入的过程：  键盘->键盘缓冲区->（回车)输入缓冲区->程序读取

 

/*

#include<iostream>

using namespace std;

#include<ctime>

int main()

{

       /*

char ch,ch2,ch3;

cout<<"input a char :"<<endl;

cin>>ch;

cout<<"ch="<<ch<<endl;

cout<<"input a char :"<<endl;

cin>> ch2;

cout<<"ch2="<<ch2<<endl;

cout<<"input a char :"<<endl;

cin>>ch3;

cout<<ch3<<endl;

cerr<<ch3<<"hello"<<endl;

 

 

 

//cout<<"hello";

cerr<<"world";

for(int i=0;i<5;i++){

       time_t t=time(NULL);

       while(time(NULL)==t);

}

cout<<endl;

 

//回车后进入【输入缓冲区】中，只要缓冲区中还有数据则直接从缓冲区中读取；

//cerr,clog用来输出时没有缓冲，也不能重定向 其用法和cout完全相同；

}//文件IO和控制台的IO完全一致；

*/

//  文件类型的准备：读入，写出；  ofstream fout("a.text");

// ofstream 变量名 ("文件名")；fout<</  fout.close();

// ifstream fin("a.text");   fin>>变量名/ fin.close();

 

/*

#include<iostream>

using namespace std;

#include<fstream>

#include<string>

 

int main()

{

       ofstream fout("a.txt");//当前目录下生成文件a.txt

       fout<<"hello, world!"<<endl;// (void*)

       fout<<123<<endl;

       fout<<4.5*6<<endl;

       fout<<'V'<<endl;

       fout.close();

       string str=" ";

       int n=0;

    double d=0.0;

       char c='/0';

       ifstream fin("a.txt");

       getline(fin,str);

       fin>>n>>d>>c;

    cout<<"n="<<n<<endl;

       cout<<"d="<<d<<endl;

       cout<<"c="<<c<<endl;

    fin.close();

       //cout<<cout<<endl;//输出的为地址、、类型转换(void*),

       //如果输入输出出错了则输出为NULL

       //cout<<cin<<endl;  // 输出为地址

       //一个O流对象在没有出错的时候可以当成真，在出错的时候可以当成假；

       //即可以看成是bool类型

 

}

*/

/*

#include<iostream>

using namespace std;

#include<fstream>

 

 

int main()

{

       ofstream fout("\abc");//不可以的时候执行出错， 输出为NULL

       ifstream fin("\abc");

       cout<<fout<<endl;

       cout<<fin<<endl;

       ofstream fout1("abc");

       ifstream fin1("abc");

       cout<<fout1<<endl;

       cout<<fin1<<endl;

 

}

*/

// --------------------------态度决定一切-----------------------

/*

统计文件的行数

#include<iostream>

using namespace std;

#include<fstream>

#include<string>

int main()

{

       char name[256];

       cin>>name;

       ifstream fin(name);

       int n=0;

       for(;;){

              string str;

              getline(fin,str);

              if(!fin) break;

              n++;

       }

              fin.close();

           cout<<n<<endl;

      

 

}

*/

/*

#include<iostream>

using namespace std;

 

class A{

int n;

public:

       A(int d):n(d){}

       friend ostream& operator<<(ostream& os,A&o)//运算符>>,<<只能以友元形式

       {

              cout<<o.n;

              return os;

       }

 

};

int main()

{

       A s(100);

       cout<<s<<endl;

       //输入：将键盘输入的各种字符转换成数据，

       //输出： 将各种数据以一串字符从屏幕输出

       //格式化输入输出

       cout<<endl;

}

*/

//1）非格式化输入：get(),getline(),read(),ignore(),peek(),putback();

//get()操作(无参)，从输入流中读取一个字读，返回字符的ASCII码。从流中取走，不再存在、

//

/*

#include<iostream>

using namespace std;

 

int main()

{

       cout<<"please Input 2 chars:;

              //若输入： aB

       cout<<cin.get()<<endl;//取值：a

       cout<< (char)cin.get()<<endl;//取值 ：B

}

*/

//2）【get(char&)】操作：从输入字符流中读取一个字符保存到形参中；

//用">>"输入时会跳过空白字符；  例如：空格， 换行等

/*

#include<iostream>

using namespace std;

int main(){

       char a,b,c,d;

       cout<<"input 4 char:";

       a=cin.get();

       cin.get(b);

       cin.get(c).get(d);//返回任然为istream类型的引用:但不提倡这样使用

    cout<<"a=["<<a<<"]"<<endl;

       cout<<"b=]"<<b<<"]"<<endl;

       cout<<"c=["<<c<<"]"<<endl;

       cout<<"d=["<<d<<"]"<<endl;

}

*/

/*

#include<iostream>

using namespace std;

#include<fstream>

#include<ctime>

 

void wait_n_minute(int n);

int main()

{

       ifstream fin("a.txt");

       for(;;){

             

        if(!fin) break;//没出错的情况下；

              wait_n_minute(2);

              #define COUT  cout<<(char)fin.get()<<flush;

              COUT;COUT;COUT;COUT;COUT;

             

              //cout<<(char)fin.get()<<flush;

              //cout<<(char)fin.get()<<flush;

              //cout<<(char)fin.get()<<flush;

              //cout<<(char)fin.get()<<flush;

       }

       fin.close();

       return 0;

}

 

void wait_n_minute(int n)

{

 

       for(int i=n;i!=0;i--)

       {    

       time_t t=time(NULL);

       while(t==time(NULL));

       }

}

转载于:https://www.cnblogs.com/sdluReaLo/archive/2013/03/08/2949874.html

diguituo4771
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++学习之路（七）
weixin_43850162的博客
02-01 330
文章目录静态联编和动态联编多态原理解析 静态联编和动态联编 多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。 多态性(polymorphism)提供接口与具体实现之间的另一层隔离，从而将”what”和”how”分离开来。多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。 c++支持编译时多态(静态...
1、
杨
08-03 189
给出如下代码段，请分析编译运行结果，并作说明； #include <iostream> using namespace std; class A { private: int value; public: A(int n) { value = n; } A(A other) { value = other.value; } void Printf() { cout << value << endl;
C++与输出
JuniorChestnut的博客
09-14 201
1. 小黑屏输出流 cout 相关解释： cout<<fixed;——fixed就是用一般的方式输出浮点数，而不是科学计数法，例如0.001—和1e-003 cout.setf(ios::fixed)——用定点格bai式显示浮点数； cout.setf(ios::showpoint)——显示浮点数小数点后的0； cout.precision(2)——设置精确度zhi为2位并返回上一次的dao设置。 2. 文件输出流Fout同cout相似：基本上都是一样的，只是输出的位置不同出现一点差别。 不同点
PTA实验题：6-5 对象数组初始化 (10 分)
巧克力曲奇饼冰淇淋的博客
07-29 4496
根据类定义，进行对象数组的定义，按照输出样例输出相应的数据。 类定义： #include<iostream> using namespace std; class A{ int data; public: A(int k=0){ data=k; } void show(){ cout<<"data="<<data<<endl; } }; ###编写main函数，定义三个对象数组，完成指定
C++类与对象（三）
qq_63580639的博客
10-15 1499
类与对象的扩展与编译器的优化
C++STL中<vector>容器基本操作
01-26
帮助新学习STL的童鞋们了解容器
cpp代码-模板 泛型 template<typename> template<class>
07-14
template <> std::string max<std::string>(std::string a, std::string b) { return a > b ? a : b; } ``` 2. 偏特化（Partial Specialization）：只对模板的一部分进行特化。这在类模板中常见，例如为`std::...
表达式计算器，支持四则与括号运算(C++)
09-01
【表达式计算器，支持四则与括号运算(C++)】是一种基于C++编程语言实现的计算机程序，主要用于解决数学表达式的计算问题。该程序利用了经典的算法——逆波兰表示法（也称为后缀表达式）来高效地进行计算。逆波兰表示...
【每日一练】day(12)
Pass-by
05-02 1148
文章目录 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
C++课后习题第三章
weixin_44906474的博客
10-12 4633
课本习题第三章第二题第三题第四题第五题 第三章 第二题 题目： 分析下列程序，写出其运行结果。 代码： #include<iostream> using namespace std; class Data { public: Data(int,int,int); Data(int,int); Data(int); Data(); void display(); private: int month; int day; int year; }; Data::Data(int
C++（例题集—简单解析-类与对象）
热门推荐
Z_sea的博客
07-08 1万+
由于自己本人上课不太认真，只能靠自己学习例题总结。希望能给大家一些便捷，让大家开心学习C++。对象的创建与使用：例题5-1    定义一个点类，生成对象，将点的坐标显示在屏幕上：#include&lt;iostream&gt; using namespace std; class Point{ int x,y; public: void setXY(int a,int b){ ...
第四章 课后习题
Lijing_666的博客
04-24 2008
一、填空题（1）如类果类A继承了B，那么类A被称为     基     类，而类B被称为     派生     类。（2）C++的两种继承为:   单继承   和  多继承   。（3）在默认情况下的继承方式为  私有继承方式  。（4）从基类中公有派生一个类时，基类的公有成员就成为派生类的  公有  成员，而这个基类的保护成员就成为派生类的  保护成员。（5）C++提供了  多继承   机制，允...
C++继承模型的内存布局
Cookie1997的小屋
03-22 581
以Clang++编译器为例。对于多继承情况考虑示例代码123struct Base1 {...};struct Base2 {...};struct Derived : Base1, Base2 {...};有如下内存布局首先出现的是派生类Derived类的虚表指针vptr（这里插入一个提醒：一直以来vptr都被国人翻译为虚函数表指针但是vtbl英文原文是virtual table并非virtua...
C++面向对象程序设计第三章部分课后习题
Atticus的博客
10-23 3217
三、 我修改的程序如下： #include<iostream> using namespace std; class Date { public: Date(int = 1, int = 1, int = 2005); void display(); private: int month; int day; int year; }; Date::Date(int m, int d, int y):month(m), day(d), year(y) { } void
C++ - 函数重载
jiaowenjie的专栏
08-06 30
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++初学者指南-5.标准库(第二部分)--数值运算算法
最新发布
silencestarsky的博客
08-06 549
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
C++模板初阶 简述
weixin_74799280的博客
08-05 196
/函数模板的实例化 有俩种方式 1.推导(类型)实例化 2.显示(类型)实例化 某种情况只能显示(类型)实例化 例如:模板类型不做形参 传递实参推导不出类型。// <>尖括号里面的叫模板参数列表 参数列表中的类型名 就是一个代号 不是创造出来的新的类型 代号还是要被内置类型或自定义类型替换。//类模板和函数模板 前面必须要有关键字(template)<class 类型代号名>//函数模板的需要: 代码通用，类型不同 函数模板能解决。//类的实例化 只能是显示(类型)实例化。
#include <string> #include <iomanip>
09-02
引用中的代码是C++中引用头文件的写法，其中#include <string>和#include <iomanip>是用于包含string和iomanip这两个库的头文件。 在C++中，#include指令用于引入头文件，以便在程序中使用相应的库函数和类。头文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值