【C++基础】类class

简介: 【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)      操作符重载后的意义应该反映操作符的本质

 

 

2、  例子:

#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;
}

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

目录
打赏
0
0
1
0
7
分享
相关文章
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
43 0
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
110 0
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
112 12
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
96 16
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
4月前
|
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
234 6
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问