C++1000行

最新推荐文章于 2024-09-20 20:27:00 发布
lcr_happy
最新推荐文章于 2024-09-20 20:27:00 发布
阅读量2k
点赞数 2
分类专栏：码代码积累 c++ 文章标签： class C++
本文链接：https://blog.csdn.net/lcr_happy/article/details/68921505
版权
码代码积累同时被 2 个专栏收录
26 篇文章 1 订阅
订阅专栏
c++
7 篇文章 0 订阅
订阅专栏
#include<iostream>
using namespace std;
class Time{
    public:
    int hour;
    int min;
    int sec;
};
int main(){

    Time t1;
    cin>>t1.hour;
    cin>>t1.min;
    cin>>t1.sec;
    cout<<t1.hour<<":"<<t1.min<<":"<<t1.sec<<endl;
    return 0;
}


#include<iostream>
using namespace std;
class Time{

    public:
    int hour;
    int minute;
    int second;
};
int main(){

    void setTime(Time&);
    void showTime(Time&);
    Time t1;
    setTime(t1);
    showTime(t1);
    Time t2;
    setTime(t2);
    showTime(t2);
    return 0; 
}

void setTime(Time& t)  //定义setTime函数
{
    cin>>t.hour;
    cin>>t.minute;
    cin>>t.second; 
} 

void showTime(Time& t)
{
    cout<<t.hour<<":"<<t.minute<<":"<<t.second<<endl;
}



#include<iostream>
using namespace std;
class Time{

    public:
    int hour;
    int minute;
    int second;
};
int main(){

    void setTime(Time&,int hour=0,int minute=0,int second=0);
    void showTime(Time&);
    Time t1;
    setTime(t1,12,34,56);
    showTime(t1);
    Time t2;
    setTime(t2);
    showTime(t2);
    return 0; 
}

void setTime(Time& t,int hour,int minute,int second)  //定义setTime函数
{
    t.hour=hour;
    t.minute=minute;
    t.second=second; 
} 

void showTime(Time& t)
{
    cout<<t.hour<<":"<<t.minute<<":"<<t.second<<endl;
}


#include<iostream>
using namespace std;

class Time{
    public:
    void setTime(int h,int m,int s){
        this->hour=h;
        this->minute=m;
        this->second=s;
    }
    void showTime(){

        cout<<"显示时间："<<endl; 
        cout<<this->hour<<":"<<this->minute<<":"<<this->second<<endl;
    }
    private:
    int hour;
    int minute;
    int second;
};

int main(){
    Time t1,t2;
    t1.setTime(12,34,56);
    t1.showTime();
    t2.setTime(23,34,45);
    t2.showTime();
    return 0;
}
//注意：此处this.hour应该换成this->hour，this在此处是一个指针 


#include<iostream>
using namespace std;
class Array_max{
    public:
    void setValue(); //对数组元素设置值
    void maxValue(); //找出数组中的最大元素
    void showMaxValue();  //输出最大值 
    private:
    int array[10];
    int max; 
} ;

void Array_max::setValue()   //成员函数定义，向数组元素输入数值
{
    int i;
    for(i=0;i<10;i++)
      cin>>array[i]; 
} 

void Array_max::maxValue() //找出最大值
{
    this->max=array[0];
    int i;
    for(i=1;i<10;i++)
    {
        if(array[i]>this->max)
          this->max=array[i];
    } 
} 

void Array_max::showMaxValue()
{
    cout<<"数组中最大的元素为："<<this->max<<endl; 
}

int main()
{
    Array_max a;
    a.setValue();
    a.maxValue();
    a.showMaxValue();
    return 0;
}


//构造函数完成对象的初始化 
/*
构造函数是一种特殊的成员函数，与其他函数不同，不需要用户来调用它，而是在建立对象时
自动执行。构造函数的名字必须与类名一直，而不能由用户任意指定，以便编译系统能识别它并把
它作为构造函数处理。
（1）在类对象进入其作用域是调用构造函数
（2）构造函数没有返回值，因此也不需要在定义构造函数时声明类型，这是它和一般函数的一个重要的不同点
（3）构造函数不需要用户调用，也不能被用户调用
（4）在构造函数的函数体重不仅可以给数据成员赋值，而且可以包含其他语句。但是一般不提倡在构造函数中加入与
初始化无关的内容，以保持程序的清晰
（5）如果用户自己没有定义构造函数，则C++系统会自动生成一个构造函数，只是这个构造函数的函数体是空的。 
*/ 

#include<iostream>
using namespace std;
class Box{
    public:
    Box(int h=10,int w=10,int len=10);  //在声明构造函数时指定默认参数，一般构造函数可以不止一个
    int volume();
    void showVolume()
    {
        cout<<"体积是："<<volume()<<endl;
    }
    private:
    int height;
    int width;
    int length; 
} ;

Box::Box(int h,int w,int len)
{
    height=h;
    width=w;
    length=len;
}

int Box::volume()
{
    return height*width*length;
}

int main()
{
    Box b1;
    b1.showVolume();
    Box b2(15); 
    b2.showVolume();
    Box b3(15,30);
    b3.showVolume();
    Box b4(15,30,20);
    b4.showVolume(); 
    return 0;
}

//析构函数
/*
当对象的生命周期结束时，会自动执行析构函数。具体地说如果出现一下几种情况，程序就会执行析构函数：
（1）如果在一个函数中定义了一个对象（它是自动局部对象），当这个函数被调用结束时，对象就应该释放
在对象释放前自动执行析构函数
（2）static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，而在main函数结束或调用exit函数结束程序时
才调用static局部对象的析构函数
（3）如果定义了一个全局对象，则在程序的流程离开其作用域时（如main函数结束或调用exit函数）时，调用该全局对象的析构函数
（4）如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数 

析构函数的作用并不是删除对象，而是在撤销对象占用内存之前完成一些清理工作。析构函数不返回任何值，没有函数类型，也没有函数
参数。由于没有函数参数，因此它不能被重载。一个类可以有多个构造函数，但是只能有一个析构函数。

如果用户没有定义析构函数，C++编译器系统会自动生成一个析构函数，但它只是徒有析构函数的名称和形式，实际上什么操作都
不进行 
*/ 

#include<iostream>
#include<string>
using namespace std;
class Student{
     public: 
     Student(int n,string nam,char s){
        num=n;
        name=nam;
        sex=s;
        cout<<"Constructor called!"<<num<<endl;
    } 
    ~Student(){
        cout<<"Destructor called!"<<num<<endl;
     }

     void display(){

        cout<<"number:"<<num<<endl;
        cout<<"name:"<<name<<endl;
        cout<<"sex:"<<sex<<endl<<endl;
    }
    private:
    int num;
    string name;
    char sex;
};

int main(){

    Student s1(10010,"xiaoming",'f');//在这里最后一个参数应使用单引号，使用双引号会报错 
    Student s2(10011,"xiaohong",'m');
    s1.display();
    s2.display();
    return 0;
}
/*运行结果： 
Constructor called!10010
Constructor called!10011
number:10010
name:xiaoming
sex:f

number:10011
name:xiaohong
sex:m

Destructor called!10011
Destructor called!10010
请按任意键继续. . .
*/
//根据执行结果可以看出先构造的后析构 


//对象数组的使用方法 
#include<iostream>
using namespace std;
class Box{

    public:
    Box(int h=10,int w=12,int len=15):height(h),width(w),length(len){

    }//用参数初始化表对数据成员初始化 
    int volume(){
        return height*width*length;
    } 
    private:
    int height;
    int width;
    int length;
} ;

int main(){

    Box a[3]={
        Box(10,12,15),
        Box(15,18,20),
        Box(16,20,26)
    };
    int i;
    for(i=0;i<3;i++)
    {
        cout<<"a["<<i+1<<"]的体积是："<<a[i].volume()<<endl; 
    }
    return 0;
}


/*对象的动态建立和释放
Box *pt;
pt=new Box;
Box *pt=new Box(12,15,18);
delete pt; 
*/

//引用静态数据成员 

#include<iostream>
using namespace std;
class Box{
    public:
    Box(int,int);
    int volume();
    static int height;
    int width;
    int length;
} ;

Box::Box(int w,int len)
{
    width=w;
    length=len;
}

int Box::volume(){
    return height*width*length;
}

int Box::height=10;//对静态数据成员初始化

int main(){

    Box a(15,20),b(20,30);
    cout<<a.height<<endl;
    cout<<b.height<<endl;
    cout<<Box::height<<endl;  //注意这种引用方法 
    cout<<"a的体积为："<<a.volume()<<endl;
    cout<<"b的体积为："<<b.volume()<<endl;
    return 0;
}


#include <iostream>
using namespace std;
class Student{

    public :
    Student(int n,int a,float s):num(n),age(a),score(s){

    } //定义构造函数
    void total(){
        sum+=score;
        count++;
    }
    static float average(){
        return sum/count;
    } 
    private:
    int num;
    int age;
    float score;
    static float sum;  //静态数据成员 
    static int count;  //静态数据成员 
};

float Student::sum=0;
int Student::count=0;

int main(){
    Student s[3]={
        Student(1000,15,98.5),
        Student(1001,16,97.2),
        Student(1002,14,99.0) 
    };
    s[0].total();
    s[1].total();
    s[2].total();
    cout<<"平均分是："<<Student::average()<<endl;
    return 0; 
} 

//将普通函数声明为友元函数 
#include<iostream>

using namespace std;
class Time{
    public:
    Time(int,int,int);
    friend void display(Time &);//声明display函数为Time类的友元函数
    private:
    int hour;
    int minute;
    int second; 
} ;

Time::Time(int h,int m,int s){
    hour=h,minute=m,second=s;
}

void display(Time& t){
    cout<<t.hour<<":"<<t.minute<<":"<<t.second<<endl;
}

int main(){

    Time t1(11,22,33);
    display(t1);
    return 0;
}

//友元成员函数
//friend函数不仅可以是一般函数（非成员函数），而且可以是另一个类中的成员函数。 

#include <iostream>
using namespace std;
class Date;   //对Date类的提前引用声明
class Time{

    public:
    Time(int,int,int);
    void display(Date &t);   //display是成员函数，形参是Date类对象的引用
    private:
    int hour;
    int minute;
    int sec; 
} ;

class Date{
    public:
    Date(int,int,int);
    friend void Time::display(Date &);  //声明Time类中的display函数为本类的友元成员函数
    private:
    int year;
    int month;
    int day; 
};

Time::Time(int h,int m,int s){
    hour=h;
    minute=m;
    sec=s;
}

void Time::display(Date &d){
    cout<<d.year<<"年"<<d.month<<"月"<<d.day<<"日"<<endl;
    cout<<hour<<":"<<minute<<":"<<sec<<endl; 
}

Date::Date(int y,int m,int d){

    year=y;
    month=m;
    day=d;
}

int main(){

    Time t1(10,13,56);
    Date d1(2004,12,25);
    t1.display(d1);
    return 0; 
}


/*关于友元函数利弊的分析：
面对对象程序设计的一个基本原则是封装性和信息隐蔽，而友元函数却可以访问其他类中的私有成员
不能不说这是对封装原则的一个小的破坏。但是他能够有助于数据共享，能提高程序的效率，在使用友元时，要注意到它的副作用
不要过多地使用友元，只有在使用它能够使程序精炼，并能大大提高程序的效率才使用友元。必须找到数据共享和信息封闭的一个恰当
的平衡点 
*/

//类模板 
//利用类模板实现两个整数，两个浮点数和两个字符的比较 
#include<iostream>
using namespace std;
template<class numtype>   //定义类模板
class Compare{
    public:
    Compare(numtype a,numtype b)
    {
        x=a;y=b;
    }
    numtype max(){
        return (x>y)?x:y;
    }
    numtype min(){
        return (x<y)?x:y;
    }
    private:
    numtype x,y;
} ;

int main(){

    Compare<int> cmp1(3,7);
    cout<<"大数："<<cmp1.max()<<endl;
    cout<<"小数："<<cmp1.min()<<endl;
    cout<<endl;
    Compare<float> cmp2(45.78,93.6);
    cout<<"大数："<<cmp2.max()<<endl;
    cout<<"小数："<<cmp2.min()<<endl;
    cout<<endl;
    Compare<char> cmp3('a','A');
    cout<<"大数："<<cmp3.max()<<endl;
    cout<<"小数："<<cmp3.min()<<endl;
    return 0;
}


#include<iostream>
using namespace std;
class Date{

    public:
    Date(int y=2005,int m=1,int d=1);
    Date(int,int);
    Date(int);
    void display();
    private:
    int year;
    int month;
    int day;
};

Date::Date(int y,int m,int d){
    year=y;
    month=m;
    day=d;
} 


Date::Date(int m,int d){
    month=m;
    day=d;
    year=2005;
}

Date::Date(int m){
    month=m;
    day=1;
    year=2005;
}


void Date::display(){
    cout<<year<<":"<<month<<":"<<day<<endl; 
}

int main(){
    Date d1(2005,10,13);
    Date d2(12,30);
    Date d3(10);
    Date d4;   //这里不应该写为Date d4();编译不能通过 

    d1.display();
    d2.display();
    d3.display();
    d4.display();

    return 0; 
}


#include<iostream>
using namespace std;

class Student
{
    public:
    Student(string n,float s){
        Num=n;
        score=s;
    }
    void display(){
        cout<<"学号："<<Num<<endl;
        cout<<"成绩："<<score<<endl; 
    }
    private:
    string Num;
    float score;
};

int main(){

    Student Stu[5]={
        Student("10010",89.8),
        Student("10011",78.9),
        Student("10012",98.6),
        Student("10013",92.5),
        Student("10014",97.4)
    } ;

    int i;
    Student *p=Stu;
    for(i=0;i<5;i++)
    {
        if(i%2==0)
           (*p).display();
        p++;
    }
    return 0;
}


#include<iostream>
using namespace std;

class Student
{
    public:
    Student(string n,float s){
        Num=n;
        score=s;
    }
    static void display(){    //显示最高成绩者的学号和成绩 
        cout<<"成绩最高者的学号："<<resNum<<endl;
        cout<<"其成绩为："<<maxValue<<endl; 
    }
    void max(){
        if(score>maxValue)
        {
            maxValue=score;
            resNum=Num;
        }
    }

    private:
    string Num;
    float score;
    static float maxValue;    //最高的成绩 
    static string resNum;    //最高成绩者的学号 
};

float Student::maxValue=0;     //对静态数据成员进行初始化 
string Student::resNum="";

int main(){

    Student Stu[5]={
        Student("10010",89.8),
        Student("10011",78.9),
        Student("10012",98.6),
        Student("10013",92.5),
        Student("10014",97.4)
    } ;
    int i;
    for(i=0;i<5;i++)
    {
        Stu[i].max();
    }
    Student::display();
    return 0;
}


#include<iostream>
using namespace std;
class Student{

    public:
    Student(int n,float s):num(n),score(s){

    }
    void change(int n,float s){
        num=n;
        score=s;
    }
    void display(){
        cout<<num<<" "<<score<<endl;
    }

    private:
    int num;
    float score;
};

int main(){

    Student stud(101,78.5);
    stud.display();
    stud.change(101,80.5);
    stud.display();
    return 0;

}


#include<iostream>
using namespace std;
class Complex{

    public:
    Complex(){ //构造函数初始化实部虚部均为0 
        this->real=0;
        this->imag=0;
    }
    Complex(double r,double i){

        this->real=r;
        this->imag=i;
      } 
    Complex complex_add(Complex &c2);  //声明复数相加的函数 
    void display();   //声明输出函数

    private:
    double real;
    double imag; 
};

Complex Complex::complex_add(Complex &c2){

    Complex c;
    c.real=this->real+c2.real;
    c.imag=this->imag+c2.imag;
    return c;
} 

void Complex::display(){
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main(){
    Complex c1(3,4),c2(5,-10),c3;
    c3=c1.complex_add(c2);
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"c1+c2=";
    c3.display();
    return 0;
}


#include<iostream>
using namespace std;
class Complex{

    public:
    Complex(){ //构造函数初始化实部虚部均为0 
        this->real=0;
        this->imag=0;
    }
    Complex(double r,double i){

        this->real=r;
        this->imag=i;
      } 
    Complex operator +(Complex &c2);  //声明重载运算符的“+”函数 
    void display();   //声明输出函数

    private:
    double real;
    double imag; 
};

Complex Complex::operator+(Complex &c2)
{
    Complex c;
    c.real=real+c2.real;
    c.imag=imag+c2.imag;
    return c;
} 

void Complex::display(){
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main(){
    Complex c1(3,4),c2(5,-10),c3;
    c3=c1+c2;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"c1+c2=";
    c3.display();
    return 0;
}

//不能重载的运算符只有5个
//.(成员访问运算符)
//.*(成员指针访问运算符)
//::(域运算符)
//sizeof(长度运算符)
//?:(条件运算符)
/*重载的规定：
（1）只能对已有的C++运算符进行重载
（2）注意使用C++中可以重载的运算符
（3）重载不能改变运算符运算对象（即操作数）的个数
（4）重载不能改变运算符的优先级别
（5）重载不能改变运算符的结合性
（6）重载运算符的函数不能有默认的参数
（7）重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象（或类对象的引用）
（8）用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“&”不必用户重载
（9）应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能
（10）运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数*/ 

#include<iostream>
using namespace std;
class Complex{

    public:
    Complex(){ //构造函数初始化实部虚部均为0 
        this->real=0;
        this->imag=0;
    }
    Complex(double r,double i){

        this->real=r;
        this->imag=i;
      } 
    friend Complex operator +(Complex &c1,Complex &c2);  //声明重载运算符的“+”函数 
    void display();   //声明输出函数

    private:
    double real;
    double imag; 
};

Complex operator+(Complex &c1,Complex &c2)
{
    Complex c;
    c.real=c1.real+c2.real;
    c.imag=c1.imag+c2.imag;
    return c;
} 

void Complex::display(){
    cout<<"("<<real<<","<<imag<<"i)"<<endl;
}

int main(){
    Complex c1(3,4),c2(5,-10),c3;
    c3=c1+c2;
    cout<<"c1=";
    c1.display();
    cout<<"c2=";
    c2.display();
    cout<<"c1+c2=";
    c3.display();
    return 0;
}  


#include<iostream>
#include<string>
using namespace std;
class String{
    public :
    String(){
        p=NULL;
    }
    String(char *str){
        this->p=str;
    }
    void display(){
        cout<<p;
    }
    friend bool operator >(String &string1,String &string2);

    private:
    char *p;
};

bool operator >(String &string1,String &string2){  //比较两个字符串的大小 
    if(strcmp(string1.p,string2.p)>0)
       return true;
    else
       return false;
}

int main(){

    String string1("Hello"),string2("Book");
    cout<<(string1>string2)<<endl; 
    return 0; 
}

#include<iostream>
using namespace std;
class String{

    public:
    String(){  //声明构造函数 
        p=NULL;
    }

    String(char  *str);  //重载构造函数
    friend bool operator >(String &string1,String &string2); 
    friend bool operator <(String &string1,String &string2);
    friend bool operator ==(String &string1,String &string2);
    void display();

    private:
    char *p;

};

String::String(char *str){
    p=str;
}

void String::display(){
    cout<<p;
}

bool operator >(String &string1,String &string2){
    if(strcmp(string1.p,string2.p)>0)
       return true;
    else
       return false;
 }

 bool operator <(String &string1,String &string2){
    if(strcmp(string1.p,string2.p)<0)
       return true;
    else
       return false;
 }

 bool operator ==(String &string1,String &string2){
    if(strcmp(string1.p,string2.p)==0)
       return true;
    else
       return false;
 }

 /*
void compare(String &string1,String &string2){
    if(operator >(string1,string2)==1){
        string1.display();
        cout<<">";
        string2.display(); 
     }
    else if(operator <(string1,string2)==1){
        string1.display();
        cout<<"<";
        string2.display(); 
    }
    else if(operator ==(string1,string2)==1){
        string1.display();
        cout<<"==";
        string2.display(); 
     }
     cout<<endl;
 }*/

 void compare(String &string1,String &string2){  //除了像上面这种方法还可以直接进行比较 
 //因为已经进行了运算符的重载，可以直接按我们习惯的大于等于小于符号的字面意思来使用 
    if(string1>string2){
        string1.display();
        cout<<">";
        string2.display(); 
     }
     if(string1<string2){
        string1.display();
        cout<<"<";
        string2.display(); 
    }
     if(string1==string2){
        string1.display();
        cout<<"==";
        string2.display(); 
    }
     cout<<endl;     //每次输出一次比较结果即换行 
 }

 int main(){
    String string1("Hello");
    String string2("Book");
    String string3("Computer");
    String string4("Hello");
    cout<<"输出比较结果："<<endl; 
    compare(string1,string2);
    compare(string2,string3);
    compare(string1,string4);
    return 0;
 }