【C++基础】类class

【意义】

Class是一种类型type,定义类的格式与struct相似,但能在定义体内添加操作;

【定义】

class Date
{
    int year;    //数据成员
    int month;
    int day;

public:        //成员函数
    void set(int y,int m,int d);//赋值操作
    void isLeapYear();//判断是否为闰年
    void print();//输出日期
};

Date d;//由类创建的实体,称为对象

【成员函数定义】定义方式有两种:

1、成员函数写入类定义中:只要是在类定义中包含的成员函数,就有默认声明内联的性质,这样能获取最佳性能

class Date
{
    int year;
    int month;
    int day;

public:
    bool isLeapYear()//判断是否为闰年
    {
        return (year%4==0&&year%100!=0)||(year%400==0);
    }
};

2、在类定义外部定义成员函数:

class Date
{
    int year;    //数据成员
    int month;
    int day;

public:        //成员函数
    void set(int y,int m,int d);//赋值操作
};

//成员函数在类外部定义时,在函数名称前应加上相应的类型名前缀和名空间引导符“::”
void Date::set(int y,int m,int d)
 {
    year=y;
    month=m;
    day=d;
}

注意事项:

函数定义体的花括号对的后面是没有分号的,而类定义体的花括号对的后面一定得有分号。

【使用对象指针】

调用成员函数的方式:

1、“.”操作符:

ObjectName.memberFunctionName(parameters);

2、以对象指针简介访问的形式:

ObjectPointer->memberFunctionName(parameters);

例子:

Date* dp=new Date;

dp->set(2000,12,6);

3、将对象指针的间访形式用括号括起来,再加点操作符“.”加成员函数:

(*ObjectPointer).memberFunctionName(parameters);

注意,不要写成*ObjectPointer.memberFunctionName(parameters);

因为操作符的优先级,导致编译出错

【常成员函数:const】

如果只对对象进行【读操作】,则该成员函数可以设计为常成员函数。

例子:

class Date
{
    int year,month,day;
public:
    void set(int y,int m,int d);
    bool isLeapYear() const;
    void print() const;
};

【重载成员函数】

成员函数与普通函数的重载识别一样

class Date
{
    int year,month,day;
public:
    void set(int y,int m,int d);
    void set(string& s);
    bool isLeapYear();
    void print();
};

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

void Date::set(string& s)
{
    year=atoi(s.substr(0,4).c_str());
    month=atoi(s.substr(5,2).c_str());
    day=atoi(s.substr(8,2).c_str());
}

【操作符重载】

1、  性质:

(1)       拒绝新创:不能创建新的操作符

(2)       个别重载限制:【::】、【.】、【.*】不能重载,因为它们都特殊地要求第二参数必须为名称;还有                 【:?】、【sizeof】、【typeof】也不允许重载

(3)       优先级和结合性不变:重载操作符后,其优先级和结合性是不会改变的。

(4)       操作数个数不变:原来操作符是几目的,重载后的操作符也是几目的

(5)       专门处理对象:操作符重载只能针对自定义类型,基本上专门用于类对象的操作

(6)       操作符重载后的意义应该反映操作符的本质

例子:

#include<iostream>
using namespace std;

class Point
{
    int x,y;
public:
    void set(int a,int b){x=a,y=b;}
    void print() const{cout<<"("<<x<<", "<<y<<")\n";}
    friend Point operator+(const Point& a,const Point& b);
    friend Point add(const Point&a,const Point& b);
};

Point operator+(const Point& a,const Point& b)
{
    Point s;
    s.set(a.x+b.x,a.y+b.y);
    return s;
}

Point add(const Point& a,const Point& b)
{
    Point s;
    s.set(a.x+b.x,a.y+b.y);
    return s;
}

int main()
{
    Point a,b;
    a.set(3,2);
    b.set(1,5);
    (a+b).print();//人们习惯的中缀表示法
    operator+(a,b).print();//重载后的调用方法
    add(a,b).print();//add函数与+的作用完全一样,因此操作符不是必须的
}

//输出结果都是(4,7)
//operator+和add函数体中都要用Point对象进行私有数据访问,作为普通函数,这是不允//许的,但将Point类中以friend关键字引导函数声明后,即可访问私有数据

【值返回和引用返回】

在设计函数时,参数若为类类型,则一般用引用型,若为内部数据类型,则不用引用型

1、  Point的+操作是两个Point对象相加,相加的结果是另外一个Point值,与两个参数无关,求和过程也不影响两个参数的值,因此,两个参数的类型为const的引用

2、  “cout<<a;”的结果是cout流,加上操作符的左结合性,所以其<<可以进行”cout<<..<<..;”式的重叠操作,重载流的<<操作时,为了保持cout这一性质,其返回值也必须是流;<<返回的cout是特定某个输出设备的流对象。若<<返回一个非引用型的流,返回时将对cout进行复制,产生一个临时的流,它会随着重叠操作而引起更多不必要的创建流操作,导致内存浪费和性能下降。

总结:Point的+操作返回Point类的值,<<操作返回流的引用

【增量操作符】

1、  一个整型变量的前增量操作的结果与变量值是一致的,而且前增量操作的结果是左值,操作可以连贯:

如:int a=1,c=1;

(++a)++;//结果a=3

++(++c);//结果c=3

2、  后增量操作的结果是增量之前的变量值,它是临时变量,当表达式计算完成后,该临时变量随即消失:

如:int b=1,d=1;

(b++)++;//结果b=2,(b++)的结果是临时变量,在其加上1随后又抛弃

++(d++);//结果d=2,解释如上

3、  重载定义:

(1)       前增量操作数与返回值是同一个变量,在反映对象的前增量操作时,要求参数为对象的引用,返回的仍然是对该对象参数的引用:

如:   X& operator++(X& a);//前增量操作数

++a;//等价与operator++(a);匹配上述操作符声明

(2)       后增量操作符重载,也要求参数为对象的引用,因为在调用的上下文中,实参将发生变化,而返回则为临时对象,所以为非引用的对象值:

如:   X& operator++(X& a,int b);//前增量操作数

a++;//等价与operator++(a,1);匹配上述操作符声明

4、  例子:

#include<iostream>
#include<iomanip>
using namespace std;

class Time
{
    int hour,minute,second;
public:
    void set(int h,int m,int s){hour=h,minute=m,second=s;}
    friend Time& operator++(Time& a);//前增量操作符的声明
    friend Time operator++(Time& a,int);//后增量操作符的声明
    friend ostream& operator<<(ostream& o,const Time& t);//输出函数声明
};

Time& operator++(Time& a)//前增操作符的定义
{
    if(!(a.second=(a.second+1)%60)&&!(a.minute=(a.minute+1)%60))
        a.hour=(a.hour+1)%24;
    return a;//前增量操作数与返回值是同一个变量,返回值仍然是对该对象参数的引用
}

Time operator++(Time& a,int)//后增操作符的定义
{
    Time t(a);//声明一个临时对象,将a的数据成员传入
    if(!(a.second=(a.second+1)%60)&&!(a.minute=(a.minute+1)%60))
        a.hour=(a.hour+1)%24;
    return t;//实参要发生变化,但是返回的位临时对象
}

ostream& operator<<(ostream& o,const Time& t)
{
    o<<setfill(‘0‘)<<setw(2)<<t.hour<<":"<<setw(2)<<t.minute<<":";
    return o<<setw(2)<<t.second<<"\n"<<setfill(‘ ‘);
}

int main()
{
    Time t;
    t.set(11,59,58);
    cout<<t++;
    cout<<++t;
}

//输出11:59:58
//    12:00:00

【成员操作符】

操作符作为类中的成员,无须冠之以friend就可以直接访问类中的任何成员了,本质上就是讲成员方法在class的内部既声明且定义。

#include<iostream>
using namespace std;

class Point
{
    int x,y;
public:
    void set(int a,int b){x=a,x=b;}
    Point operator+(const Point& d)
    {
        Point s;
        s.set(x+d.x,y+d.y);
        return s;
    }
    friend ostream& operator<<(ostream& o,const Point& d);
};

inline ostream& operator<<(ostream& o,const Point& d)
{
    return o<<"("<<d.x<<", "<<d.y<<")\n";
}

int main()
{
    Point s,t;
    s.set(2,5);
    t.set(3,1);
    cout<<s+t;
}

普通操作符(需要在class内部声明前加friend)
Point operator+(const Point& a,const Point& b)
{
    Point s;
    s.set(a.x+b.x,a.y+b.y);
    return s;
}

成员操作符
Point operator+(const Point& d)
{
    Point s;
    s.set(x+d.x,y+d.y);
    return s;
}

两者相比,成员操作符省略了第一个参数,因为成员函数总是与对象捆绑使用。被捆绑的对象就是被操作的第一参数

【C++基础】类class

时间: 2024-10-09 01:48:10

【C++基础】类class的相关文章

OC基础 类的三大特性

OC基础  类的三大特性 OC的类和JAVA一样,都有三大特性:继承,封装,多态,那么我们就来看一下OC中类的三大特性. 1.继承 继承的特点: (1)子类从父类继承了属性和方法. (2)子类独有的属性和方法不能被父类使用. (3)子类独有的属性和方法,不能够在子类之间互相使用. (4)子类能够重写父类的方法,子类调用该方法时:首先调用子类的方法,如果子类没有该方法,就调用父类的该方法. (5)子类对象指针可以转换成父类对象指针,但是父类对象指针不能够转换成子类对象指针. 三种权限变量的继承:

设计模式基础:类及类关系的UML表示

设计模式基础:类及类关系的UML表示 2009-10-26 17:00 by 宗哥, 1891 阅读, 1 评论, 收藏, 编辑 UML中,类关系分为这几种,泛化(generalization), 实现(realization),依赖(Dependency),关联(associate),聚合(aggregation),(composition)下面分别是UML实现及C#中的代码表现. 泛化(generalization) 泛化也称作特化(specialization),用来表示一个更一般和更特殊

python基础(类、对象、包)完整的总结

python基础(类和对象.包)类和对象对象是看的见摸的着的类是模板对象需要类才能创建出来类的构成(三个部分)类的名称:类名类的属性:一组数据类的方法:允许进行操作的方法(行为)class 类名():def添加方法class Cat():def run(self):print("cat is running")xiaobai = Cat()xiaobai.run()xiaobai.name = "小白"xiaobai.age = 40类的属性属性就是变量一个类可以创

第31节:Java基础-类与对象

前言 Java基础-类与对象,方法的重载,构造方法的重载,static关键字,main()方法,this关键字,包,访问权限,类的继承,继承性,方法的重写,super变量. 方法的重载:成员方法的重载和构造方法的重载 方法的重载 在一个类中可以有多个方法具有相同的名字,但是这些方法的参数个数不同,或参数类型不同,即为方法的重载. class Demo{ // one void dashu(String name){ System.out.println(name); } // two void

c#核心基础--类的继承

继承 一个类可以继承自另一个类.在 C#中,类与类之间只存在单一继承.也就是说,一个类的直接基类只能有一个.当类与类之间实现继承的时候,子类可以将它的直接基类的所有成员当做自己的成员,除了类的静态构造方法.实例构造方法和析构方法.但是,虽然基类的所有成员都可以当做子类的成员,但是如果基类的成员设置了不同的访问权限,则派生类可以访问的成员也随之不同.C#的继承是可以传递的,如果类C从类B派生,而类B从类A派生,则类C将继类B的所有成员,也继承类A的所有成员(各个基类的静态构造方法.实例构造方法和析

Python基础- 类和对象(使用、继承、派生、组合、接口、多态、封装、property、staticmethod、classmethod、反射、slots、上下文管理协议、元类)

标签: python对象 2017-07-01 16:28 79人阅读 评论(0) 收藏 举报  分类: python(11)  版权声明:本文为广大朋友交流学习,如有纰漏望不吝赐教,若存在版权侵犯请及时与我联系 目录(?)[+] 一.初识类和对象 在python3中类型就是类 先定义类在产生相对应的对象,也就是现有了概念再有了实体 class Garen: camp = 'Demacia' def attack(self): print('attack') 1.如何使用类 在python3:

Java基础-类

Java基础第八天 类的初始化过程 Student s = new Student();在内存中做了哪些事情? 加载Student.class文件进内存 在栈内存为s开辟空间 在堆内存为学生对象开辟空间 对学生对象的成员变量进行默认初始化 对学生对象的成员变量进行显示初始化 通过构造方法对学生对象的成员变量赋值 学生对象初始化完毕,把对象地址赋值给s变量 面向对象练习 定义一个类Demo,其中定义一个求两个数据和的方法,定义一个测试了Test,进行测试.   /* 定义一个类Demo,其中定义一

JavaSE7基础 类中 调用静态成员方法的三种方法

版本参数:jdk-7u72-windows-i586注意事项:博文内容仅供参考,不可用于其他用途. 代码 class Test{ //静态成员方法 public static void sayHello(){ System.out.println("hello"); } //static ,被这个类的所有对象共享 } class Demo{ public static void main(String[] args){ Test t1 = new Test(); t1.sayHello

JavaSE7基础 类中成员方法 局部与成员变量名字相同时,使用this访问成员变量

版本参数:jdk-7u72-windows-i586注意事项:博文内容仅供参考,不可用于其他用途. 代码 class Test{ String name; //借助公有的成员方法 访问私有的成员方法 public void setName(String name){ this.name=name; //当前类的对象中的成员变量name = 函数参数列表中局部变量中的name //this 当前类的对象, t对象调用setName方法,this就代表了t } } class Demo{ publi

JavaSE7基础 类中公有成员方法 setXxx()/getXxx()

版本参数:jdk-7u72-windows-i586注意事项:博文内容仅供参考,不可用于其他用途. 代码 //这个set/get函数和C#里的属性很像,但又有不同点,我还是感觉c#里的属性好用一些. class Test{ private int age;//只能在本类中访问 //共有的成员方法 去过滤 要赋给私有成员变量的值 public void setAge(int age){ if(age<0 || age>120){ System.out.println("年龄赋值有误&q