C++学习1

最新推荐文章于 2024-11-18 18:21:45 发布
原创 最新推荐文章于 2024-11-18 18:21:45 发布 · 1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

尼玛，转眼两个月过去了，C++课翘了那么多次，然后翘着翘着，马上就期末考试了，听说是11月28号，可是各种类啊，对象啊，还没搞清楚是啥回事，好不容易想去上课了，尼玛睡过了...


今天把程序过一遍吧，过两天再看看概念，应该没事....


//******************************
//    第一章 to 第六章 
//  。。。。。。。。。。。
//******************************

几个点意思一下就行了 


//***********************
//    第七章 类与对象
//***********************

//  模拟时钟
#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        void settime(int h,int m,int s)
        {
            H=(h>=0&&h<24)?h:0;
            M=(m>=0&&m<60)?m:0;
            S=(s>=0&&s<60)?s:0;
        }
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
};
clock myclock;
int main()
{
    myclock.showtime();
    myclock.settime(8,30,30);
    myclock.showtime();
    return 0;
}



//   构造函数与析构函数
//通过这个程序可以看出析构函数的执行顺序

#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        clock(int h=0,int m=0,int s=0)
        {
            H=h,M=m,S=s;
            cout<<"constructor:"<<H<<":"<<M<<":"<<S<<endl;
        }
        ~clock()
        {
            cout<<"destructor:"<<H<<":"<<M<<":"<<S<<endl;
        }
};
int main()
{
    clock c3(10,0,0);
    clock c4(11,0,0);
    return 0;
}
clock c1(8,0,0);
clock c2(9,0,0);


// 字符串类与对象

#include <iostream>
#include <cstring>
using namespace std;
class String
{
    private:
        char *str;
        int len;
    public:
        void showstr()
        {
            cout<<"string:"<<str<<",length:"<<len<<endl;
        }
        String()
        {
            len=0;
            str=NULL;
        }
        String(const char *p)
        {
            len=strlen(p);
            str=new char[len+1];
            strcpy(str,p);
        }
        ~String()
        {
            if(str!=NULL)
            {
                delete [] str;
                str=NULL;
            }
        }
};
int main()
{
    char s[]="ABCDE";
    String s1(s);
    String s2("12345");
    s1.showstr();
    s2.showstr();
    return 0;
}


//带拷贝函数的始终类
//

#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        clock(int h=0,int m=0,int s=0)
        {
            H=h,M=m,S=s;
            cout<<"constructor:"<<H<<":"<<M<<":"<<S<<endl;
        }
        ~clock()
        {
            cout<<"destructor:"<<H<<":"<<M<<":"<<S<<endl;
        }
        clock(clock &p)
        {
            cout<<"copy constructor,before call:"<<H<<":"<<M<<":"<<S<<endl;
            H=p.H;
            M=p.M;
            S=p.S;
        }
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
};
clock fun(clock c)
{
    return c;//用已存在的对象c建立临时对象，调用拷贝
}
int main()
{
    clock c1(8,0,0);
    clock c2(9,0,0);
    clock c3(c1);
    fun(c2);
    clock c4;
    c4=c2;
    return 0;
}


//带时间加法的时钟类
//

#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        void settime(int h,int m,int s)
        {
            H=h;
            M=m;
            S=s;
        }
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
        clock(int h=0,int m=0,int s=0)
        {
            H=h;M=m;S=s;
        }
        clock(clock &p)
        {
            H=p.H;
            M=p.M;
            S=p.S;
        }
        void timeadd(clock *cp);
        void timeadd(int h,int m,int s);
        void timeadd(int s);
};
void clock::timeadd(clock *cp)
{
    H=(cp->H+H+(cp->M+M+(cp->S+S)/60)/60)%24;
    M=(cp->M+M+(cp->S+S)/60)%60;
    S=(cp->S+S)%60;
}
void clock::timeadd(int h,int m,int s)
{
    H=(h+H+(m+M+(s+S)/60)/60)%24;
    M=(m+M+(s+S)/60)%60;
    S=(S+s)%60;
}
void clock::timeadd(int s)
{
    H=(H+(M+(S+s)/60)/60)%24;
    M=(M+(S+s)/60)%60;
    S=(S+s)%60;
}
int main()
{
    clock c1;
    clock c2(8,20,20);
    c1.timeadd(4000);
    c1.showtime();
    c2.timeadd(&c1);
    c2.showtime();
    return 0;
}


//总评成绩的一个score类
//好SB的程序，运行效率也低

#include <iostream>
using namespace std;
const int maxn=100;
const double rate=0.6;
class Score
{
    private:
        long No;
        char *Name;
        int Peace;
        int Final;
        int Total;
    public:
        Score(long =0,char * =NULL,int =0,int =0,int =0);
        void count();
        void showscore();
};
Score::Score(long no,char *name,int peace,int final,int total)
{
    No=no;
    Name=name;
    Peace=peace;
    Total=total;
    Final=final;
}
void Score::count()
{
    Total=Peace*rate+(1-rate)*Final+0.5;
    return ;
}
void Score::showscore()

{
    cout<<No<<"\t"<<Name<<"\t\t"<<Peace<<"\t"<<Final<<"\t"<<Total<<endl;
}
int main()
{
    Score classscore1[3];
    Score classscore2[3]={Score(200607001,"LiuNa",80,79),
    Score(200607002,"CuiPeng",90,85),Score(200607003,"ZhouJun",70,55)};
    for(int i=0;i<3;i++)
        classscore2[i].count();
    for(int i=0;i<3;i++)
        classscore2[i].showscore();
    return 0;
}


//计算火车旅程的组合类
//

#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
        void settime(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        clock(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        int geth()
        {
            return H;
        }
        int getm()
        {
            return M;
        }
        int gets()
        {
            return S;
        }
};
class traintrip
{
    private:
        char *trainno;
        clock starttime;
        clock endtime;
    public:
        traintrip(char * trainno,clock S,clock E)
        {
            this->trainno=trainno;
            starttime=S;
            endtime=E;
        }
        clock triptime()
        {
            int tH,tM,tS;
            int carry=0;
            clock ttime;
            (tS=endtime.gets()-starttime.gets())>0?carry=0:tS+=60,carry=1;
            (tM=endtime.getm()-starttime.getm()-carry)>0?carry=0:tM+=60,carry=1;
            (tH=endtime.geth()-starttime.geth()-carry)>0?carry=0:tH+=24;
            ttime.settime(tH,tM,tS);
            return ttime;
        }
};
int main()
{
    clock c1(8,10,10),c2(6,1,2);
    clock c3;
    traintrip t1("K16",c1,c2);
    c3=t1.triptime();
    c3.showtime();
    return 0;
}


//含有对象计数器的学生类

#include <iostream>
#include <cstring>
using namespace std;
class student
{
    private:
        char *name;
        int no ;
        static int counts;
    public:
        static int getcount()
        {
            return counts;
        }
        student(char* ="",int =0);
        student(student &);
        ~student();
};
student::student(char *name,int no)
{
    this->name=new char [strlen(name)+1];
    strcpy(this->name,name);
    this->no=no;
    ++counts;
    cout<<"constructing:"<<name<<endl;
}
student::student(student &r)
{
    name=new char [strlen(r.name)+1];
    strcpy(name,r.name);
    no=r.no;
    ++counts;
    cout<<"copy constructing:"<<r.name<<endl;
}
student::~student()
{
    cout<<"destructing:"<<name<<endl;
    delete [] name;
    --counts;
}
int student::counts=0;
int main()
{
    cout<<student::getcount()<<endl;
    student s1("Antony");
    cout<<s1.getcount()<<endl;
    student s2(s1);
    cout<<s1.getcount()<<endl;
    student s3[2];
    cout<<student::getcount()<<endl;
    student *s4=new student[3];
    cout<<student::getcount()<<endl;
    delete [] s4;
    cout<<student::getcount()<<endl;
    return 0;
}


//计算火车旅途时间的友元函数

#include <iostream>
using namespace std;
class clock
{
    private:
        int H,M,S;
    public:
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
        void settime(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        clock(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        friend clock triptime(clock &starttime,clock &endtime);
};
clock triptime(clock &starttime,clock &endtime)
{
    int tH,tM,tS;
    int carry=0;
    clock ttime;
    (tS=endtime.S-starttime.S)>0?carry=0:tS+=60,carry=1;
    (tM=endtime.M-starttime.M-carry)>0?carry=0:tM+=60,carry=1;
    (tH=endtime.H-starttime.H-carry)>0?carry=0:tH+=24;
    ttime.settime(tH,tM,tS);
    return ttime;
}
int main()
{
    clock c1(8,10,10),c2(6,1,2);
    clock c3;
    c3=triptime(c1,c2);
    c3.showtime();
    return 0;
}


//计算吗火车旅途时间的友元类

#include <iostream>
using namespace std;
class traintrip;
class clock
{
    private:
        int H,M,S;
    public:
        void showtime()
        {
            cout<<H<<":"<<M<<":"<<S<<endl;
        }
        void settime(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        clock(int H=0,int M=0,int S=0)
        {
            this->H=H;
            this->M=M;
            this->S=S;
        }
        friend class traintrip;
};
class traintrip
{
    private:
        char *trainno;
        clock starttime,endtime;
    public:
        traintrip(char *trainno,clock S,clock E)
        {
            this->trainno=trainno;
            starttime=S;
            endtime=E;
        }
        clock triptime()
        {
            int tH,tM,tS;
            int carry=0;
            clock ttime;
            (tS=endtime.S-starttime.S)>0?carry=0:tS+=60,carry=1;
            (tM=endtime.M-starttime.M-carry)>0?carry=0:tM+=60,carry=1;
            (tH=endtime.H-starttime.H-carry)>0?carry=0:tH+=24;
            ttime.settime(tH,tM,tS);
            return ttime;
        }
};
int main()
{
    clock c1(8,10,10),c2(6,1,2);
    clock c3;
    traintrip t1("K16",c1,c2);
    c3=t1.triptime();
    c3.showtime();
    return 0;
}


// 常数据成员的使用
//
#include <iostream>
using namespace std;
class A
{
    private:
        const int &r;
        const int a;
        static const int b;
    public:
        A(int i):a(i),r(a)
        {
            cout<<"constructor!"<<endl;
        }
        void display()
        {
            cout<<a<<","<<b<<","<<r<<endl;
        }
};
const int A::b=3;
int main()
{
    A a1(1);
    a1.display();
    A a2(2);
    a2.display();
    return 0;
}


//************************
//   第八章 继承与派生
//************************



//单继承的构造与析构
//
#include <iostream>
using namespace std;
class point
{
    private:
        int x,y;
    public:
        point(int x=0,int y=0)
        {
            this->x=x;
            this->y=y;
            cout<<"point("<<x<<","<<y<<") constructing..."<<endl;
        }
        ~point()
        {
            cout<<"point("<<x<<","<<y<<") destructing..."<<endl;
        }
};
class circle:protected point
{
    protected:
        double radius;
    public:
        circle(double r=0,int x=0,int y=0):point(x,y)
        {
            radius=r;
            cout<<"circle constructing,radius:"<<r<<endl;
        }
        ~circle()
        {
            cout<<"circle destructing,radius:"<<radius<<endl;
        }
};
class tube:protected circle
{
    private:
        double heigth;
        circle incircle;
    public:
        tube(double h,double r1,double r2=0,int x=0,int y=0):
        incircle(r2,x,y),circle(r1,x,y)
        {
            heigth=h;
            cout<<"tube constructing,heigth:"<<h<<endl;
        }
        ~tube()
        {
            cout<<"tube destructing,heigth:"<<heigth<<endl;
        }
};
int main()
{
    tube tu(100,20,5);
    return 0;
}


//多继承的二义性
//
#include <iostream>
using namespace std;
class car
{
    private:
        int power;
        int seat;
    public:
        car(int power,int seat)
        {
            this->power=power;
            this->seat=seat;
        }
        void show()
        {
            cout<<"car power:"<<power<<" seat:"<<seat<<endl;
        }
};
class wagon
{
    private:
        int power;
        int load;
    public:
        wagon(int power,int load)
        {
            this->power=power;
            this->load=load;
        }
        void show()
        {
            cout<<"wagon power:"<<power<<" load:"<<load<<endl;
        }
};
class stationwagon:public car,public wagon
{
    public:
        stationwagon(int power,int seat,int load):wagon(power,load),
        car(power,seat)
        {
        }
        void showsw()
        {
            cout<<"stationwagon:"<<endl;
            car::show();
            wagon::show();
        }
};
int main()
{
    stationwagon sw(105,3,8);
    sw.showsw();
    return 0;
}


//虚基类的构造函数
//
#include <iostream>
using namespace std;
class automobile
{
    private:
        int power;
    public:
        automobile(int power)
        {
            this->power=power;
            cout<<"automobile constructing..."<<endl;
        }
        void show()
        {
            cout<<" power: "<<power;
        }
};
class car:virtual public automobile
{
    private:
        int seat;
    public:
        car(int power,int seat):automobile(power)
        {
            this->seat=seat;
            cout<<"car constructing..."<<endl;
        }
        void show()
        {
            cout<<"car";
            automobile::show();
            cout<<" seat:"<<seat<<endl;
        }
};
class wagon:virtual public automobile
{
    private:
        int load;
    public:
        wagon(int power,int load):automobile(power)
        {
            this->load=load;
            cout<<"wagon constructing..."<<endl;
        }
        void show()
        {
            cout<<"wagon:";
            automobile::show();
            cout<<" load:"<<load<<endl;
        }
};
class stationwagon:public car,public wagon
{
    public:
        stationwagon(int cpower,int wpower,int seat,int load)
        :automobile(cpower),wagon(wpower,load),car(cpower,seat)
        {
            cout<<"station constructing..."<<endl;
        }
        void show()
        {
            cout<<"stationwagon:"<<endl;
            car::show();
            wagon::show();
        }
};
int main()
{
    stationwagon sw(105,108,3,8);
    sw.show();
    return 0;
}




//******************
//   第九章 多态性
//******************



//重载+-*/为类的成员函数
//负数运算
//
#include <iostream>
using namespace std;
class Complex
{
    private:
        double real;
        double image;
    public:
        Complex(double real=0.0,double image=0.0)
        {
            this->real=real;
            this->image=image;
        }
        void display()
        {
            cout<<"("<<real<<","<<image<<")"<<endl;
        }
        Complex operator + (Complex B);
        Complex operator - (Complex B);
        Complex operator - ();
        Complex operator ++ ();
        Complex operator ++ (int);
};
Complex Complex::operator + (Complex B)
{
    return Complex(real+B.real,image+B.image);
}
Complex Complex::operator - (Complex B)
{
    return Complex(real-B.real,image-B.image);
}
Complex Complex::operator - ()
{
    return Complex(-real,-image);
}
Complex Complex::operator ++()
{
    return Complex(++real,image);
}
Complex Complex::operator ++(int)
{
    return Complex(real++,image);
}
int main()
{
    Complex A(100.0,200.0),B(-10.0,20.0),C;
    cout<<"A = ",A.display();
    cout<<"B = ",B.display();
    C=A+B;
    cout<<"C= A+B = ",C.display();
    C=A-B;
    cout<<"C= A-B = ",C.display();
    C=-A+B;
    cout<<"C= -A+B = ",C.display();
    C=A++;
    cout<<"C= A++ = ",C.display();
    C=++A;
    cout<<"C= ++A = ",C.display();
    C=A+5;
    C.display();
    return 0;
}


//重载->为类的成员函数
//
#include <iostream>
using namespace std;
class complex
{
    private:
        double real;
        double image;
    public:
        complex(double real=0.0,double image=0.0)
        {
            this->real=real;
            this->image=image;
        }
        void display()
        {
            cout<<"("<<real<<","<<image<<")"<<endl;
        }
};
class pccomplex
{
    private:
        complex *pc;
    public:
        pccomplex(complex * pc =NULL)
        {
            this->pc=pc;
        }
        complex * operator->()
        {
            static complex nullcomplex(0,0);
            if(pc==NULL)
            {
                return &nullcomplex;
            }
            return pc;
        }
};
int main()
{
    pccomplex p1;
    p1-> display();
    complex c1(100,200);
    p1=&c1;
    p1->display();
    return 0;
}


//重载下标运算符[]为类的成员函数的字符串类
//
#include <iostream>
#include <cstring>
using namespace std;
class String
{
    private:
        char *str;
        int len;
    public:
        void showstr()
        {
            cout<<"String:"<<str<<",length:"<<len<<endl;
        }
        String(const char *p=NULL)
        {
            if(p)
            {
                len=strlen(p);
                str=new char [len+1];
                strcpy(str,p);
            }
            else
            {
                len=0;
                str=NULL;
            }
        }
        ~String()
        {
            if(str!=NULL)
            {
                delete [] str;
            }
        }
        char &operator[](int n)
        {
            return *(str+n);
        }
        const char &operator[](int n)const
        {
            return *(str+n);
        }
};
int main()
{
    String s1("0123456789abcdef");
    s1.showstr();
    s1[10]='A';
    cout<<"s1[10]=A"<<endl;
    const String s2("ABCDEFGHIJKLMN");
    s1.showstr();
    cout<<"s2[10]="<<s2[10]<<endl;
    return 0;
}


//虚析构函数
//删除动态对象析构函数的调用

#include <iostream>
using namespace std;
class A
{
    public:
        virtual ~A()
        {
            cout<<"A::~A() is called."<<endl;
        }
        A()
        {
            cout<<"A::A() is called."<<endl;
        }
};
class B:public A
{
    private:
        int *ip;
    public:
        B(int size=0)
        {
            ip=new int [size];
            cout<<"B::B() is called."<<endl;
        }
        ~B()
        {
            cout<<"B::~B() is called."<<endl;
            delete [] ip;
        }
};
int main()
{
    A *b=new B(10);
    delete b;
    return 0;
}


本来有个抽象类的函数的，可是看到书上的cout后面接的是“>>”,立马无语了，然后看了下，还是不大会，有时间看看....


//******************************
//    第十章 类模版与STL
//******************************

书上的程序了还真错了不少....


坑爹的马基课在召唤我......擦


好冷.....

C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 11万+
C/C++学习路线总结与分享
C/C++程序员为什么要了解汇编？了解汇编有哪些好处？如何学习汇编？
热门推荐
dvlinker的技术专栏
10-09 15万+
本文详细讲解了C++程序员为什么要了解汇编，了解汇编都有哪些具体的好处，如何学习汇编，以及如何看懂汇编代码上下文等，希望能给大家提供一定的借鉴或参考。
C++之virtual（虚）关键字：虚基类（虚继承）；虚函数和纯虚函数
qq_43148810的博客
10-29 3830
@著作权归作者所有：来自优快云博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.youkuaiyun.com/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! 一、虚基类 1、为什么要虚基类或者说虚继承： a、直接二义性可以用作用域与同名覆盖的方法来消除（看程序注释），但是间接二义性(同名数据成员在内存中同时拥有多个拷贝，同一个成员函数会有多个映射,多...
20170412-cpp上机作业【复制构造函数】
Fu4ng
05-15 382
这次作业有点难了。（因为我上理论课的时候在睡觉……）题目如下： *上周讲过，对象赋值时，(1) 对象的赋值只对其中的数据成员赋值，而不对成员函数赋值；(2) 类的数据成员中不能包括动态分配的数据，否则在赋值时可能出现严重后果。 例如： class String {public: String(const char* p); private: int len; int Str;
编程中的计算问题
Zangyuanfeng123的博客
10-10 2096
将x的平方赋值给y （5 分） 假设x的值为3，计算x的平方并赋值给y，分别以“y = x ∗ x”和“x ∗ x = y”的形式输出x和y的值。 输入格式： 本题无输入 输出格式： 按照下列格式输出代入x=3的结果： y = x * x x * x = y #include&amp;lt;stdio.h&amp;gt; int main() { int x,y; x=3; y=x*x; printf(“9 ...
拷贝构造函数
了解的越多，越知道自己的无知
07-02 767
拷贝构造函数是与类名相同，形参shi
类与对象
lei13789的博客
04-29 205
....字符串类与对象.... #include<iostream> using namespace std; class String { private: char*Str; int len; public: void ShowStr() { cout<<"string:"<<Str<<",length:"<<len&l...
精选资源
C++核心学习笔记pdf
03-22
C++核心学习笔记pdf
精选资源
Visual C++ 2010学习版.zip
06-08
1. 创建新项目：在Visual Studio中，用户可以通过“文件”菜单的“新建”选项来创建一个新的C++项目。选择相应的项目类型，如控制台应用程序，然后填写项目名称和位置。 2. 编辑源代码：在打开的源代码文件（通常是...
C++学习顺序
最新发布
ljw的博客
11-18 2400
C++是一种支持面向对象、泛型编程和多重编程范式的强大语言。GCC：GNU编译器集合，广泛应用于Linux。：Microsoft开发的强大IDE，适用于Windows。CLion：JetBrains开发的跨平台IDE，支持CMake构建系统。C++是一门功能强大的语言，掌握C++的编程技能需要不断的实践和学习。从基础语法到面向对象编程，再到STL的应用，最后到高级特性如智能指针和多线程编程，每个部分都在C++的学习过程中占有重要位置。
友元
weixin_42422557的博客
05-13 266
概念：在C++中，类具有封装性和隐蔽性，只有类的函数成员才能访问类的私有成员，程序中的其他函数是无法访问类的私有成员，友元为类的封装隐藏开了一个小孔，外界可以访问类内部的一些属性。如果某个对象说明为某个类的友元函数，那么这个外界对象就可以访问这个类对象中的私有成员。 PS：友元不是类的成员，但它可以访问类的任何成员。 友元分为友元函数和友元类。 一、友元函数 计算火车旅途时间的友元函数 ...
计算火车运行的时间 （C语言）
qq_65875308的博客
06-06 6590
C语言
类和对象之友元
可乐不解渴
06-05 1040
二、友元 友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。 2.1 友元函数 友元函数是在类定义中由关键字friend修饰的非成员函数。其格式如下： friend 返沪类型 函数名(形参表) { //函数体 } 示例 class Person { friend istream& operator>>(istream& in, Person&a
第七周上机实践项目：时钟类简单程序
qq_33757765的博客
04-14 376
/*Copyright (c)2016,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：aaa.cpp *作 者：赵子琳 *完成日期：2016年4月14日 *版 本 号：v1.0 * *问题描述：编写时钟。 */ #include using namespace std; class C
分支-12. 计算火车运行时间(15)
Jason王祖龙
06-02 1万+
本题要求根据火车的出发时间和达到时间，编写程序计算整个旅途所用的时间。 输入格式： 输入在一行中给出2个4位正整数，其间以空格分隔，分别表示火车的出发时间和到达时间。每个时间的格式为2位小时数（00-23）和2位分钟数（00-59），假设出发和到达在同一天内。 输出格式： 在一行输出该旅途所用的时间，格式为“hh:mm”，其中hh为2位小时数、mm为2位分钟数。 输入样例
C++学习（3）
weixin_30439067的博客
08-15 95
今天大体看了一下友元类以及类的派生，敲了敲书上的样例，感觉懂了不少： 1）友元类：如果一个类声明为另一个类的友元，则，该类称为另一个类的友元类。 若A类为B类的友元类，则A类的所有成员函数都是B类的友元函数，都可以访问B类的任何数据成员。 友元类 1 //友元类的使用 2 //友元关系不能传递，B是A友元，C是B的友元，C和A之间，如果没有声明，就没有任何友元关系，不能进行数据共享...
C++成长之路（8）——类和对象
qq_36045093的博客
03-03 1095
类和对象的定义 对象是现实中的对象在程序中的模拟。 类是同一类对象的抽象，对象是类的某一特定实体。 定义类的对象，才可以通过对象使用类中定义的功能。 设计类就是设计类型 此类型的“合法值”是什么？ 此类型应该有什么样的函数和操作符？ 新类型的对象该如何被创建和销毁？ 如何进行对象的初始化和赋值？ 对象作为函数的参数如何以值传递？ 谁将使用此类型的对象成员？ 类定义的语法形式 ...
设计包含静态数据成员的Student类
juddi的专栏
10-19 5634
设计包含静态数据成员的Student类，在该类定义中包括： 数据成员：学号，年龄，分数score，及静态数据成员学生人数count； 定义成员函数用于设置和读取及显示学号，年龄，分数，累计学生人数；静态成员函数getCount( ) 用于返回总人数；外部函数average()用于求平均值。 在main函数中，输入某班同学的成绩，并调用上述函数求全班学生的平均分。   #include &...
计算火车运行时间
qq_63068918的博客
04-09 2581
根据火车的出发时间和达到时间，编写程序计算整个旅途所用的时间。 Input 多测试用例，每个测试用例占一行：是 2 个 4 位正整数，其间以空格分隔，分别表示火车的出发时间和到达时间。 每个时间的格式为 2 位小时数（00-23）和 2 位分钟数（00-59），假设出发和到达在同一天内。 Output 一个测试用例输出一行：该旅途所用的时间，格式为 “hh:mm”，其中hh为 2 位小时数、mm为 2 位分钟数。 Sample Input 1201 1530 0935 1940 1159...
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值