封闭类、友元、this指针、常量对象

最新推荐文章于 2023-12-09 18:48:07 发布
最新推荐文章于 2023-12-09 18:48:07 发布
阅读量842 收藏
点赞数 2
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JSRGFJZ/article/details/51056046
版权

成员对象和封闭类

成员对象：一个类的成员变量是另一个类的对象
封闭类：包含成员对象的类是封闭类

class CTyre{
public:
    CTyre(int a,int b):radius(a),width(b){}
protected:
private:
    int radius;
    int width;
};

class CEngine{
public:
protected:
private:
};

class CCar{
public:
    CCar(int a,int b,int c);
protected:
private:
    int price;
    CTyre tyre;CEngine engine;
};

CCar::CCar(int a,int b,int c):price(a),tyre(b,c){};

int main(){
    CCar a(1,2,3);
    return 0;
}

封闭类构造函数的初始化列表

类名：构造函数(参数表)：成员变量1(参数表)，成员变量2(参数表)……{}

调用顺序
封闭类对象生成时：
– 1.执行所有成员对象构造函数
– 2.执行封闭类的构造函数
成员对象构造函数
–和成员对象在类中说明顺序一致
–与成员初始化列表中出现顺序无关
封闭类对象消亡时
–先执行封闭类的析构函数
–再执行成员对象的析构函数

构造函数调用顺序与析构函数调用顺序想反
对比分析

class CTyre{
private:
    int radius, width;
public:
    CTyre() {
        cout << "CTyre constructor called" << endl;
    }
    ~CTyre() {
        cout << "CTyre deconstructor called" << endl;
    }
};

class CEngine{
private:
public:
    CEngine() {
        cout << "CEngine constructor called" << endl;
    }
    ~CEngine() {
        cout << "CEngine deconstructor called" << endl;
    }
};

class CCar{
private:
    CTyre tyre; CEngine engine;
public:
    CCar() {
        cout << "CCar constructor called" << endl;
    }
    ~CCar() {
        cout << "CCar deconstructor called" << endl;
    }
};

这里写图片描述

如果类CCar变成

class CCar{
private:
    CEngine engine;CTyre tyre; 
public:
    CCar() {
        cout << "CCar constructor called" << endl;
    }
    ~CCar() {
        cout << "CCar deconstructor called" << endl;
    }
};

这里写图片描述

友元

  • 友元函数

一个类的友元函数（包括构造、解析函数）
可以访问该类的私有成员

class CCar;
class CDriver{
private:
public:
    void modify(CCar &p);
};

class CCar{
private:
    int price;
public:
    CCar(int x):price(x){}
    friend void CDriver::modify(CCar& p);
    void print() {
        cout << price << endl;
    }
};

void CDriver::modify(CCar& p) {
    p.price += 100;
}

int main() {
    CCar a(0);
    CDriver b;
    a.print();
    b.modify(a);
    a.print();
    return 0;

这里写图片描述

注意：
modify函数不能写在前面

  • 友元类

A是B的友元类，A可以访问B的私有成员
友元函数博客总结

class ccar{
public:
protected:
private:
    int price;
    friend class cd;
};

class cd{
public:
    ccar my;
    void modify(){
        my.price+=1000;
    }
protected:
private:

};

int main(){
    return 0;
}

友元类之间的关系不是传递，不是继承的。

this 指针

c++到c程序的翻译

class a{
public:
    void set(int b){
        price=b;
    }
protected:
private:
    int price;
};

int main(){
    a cc;
    cc.set(2);
    return 0;
}

对应c语言版本

struct CCar {
    int price;
};
void SetPrice(struct CCar * this,int p){
    this->price = p; 
}
int main() {
    struct CCar car;
    SetPrice( & car, 20000);
    return 0;//编译不能通过
}

其作用就是指向成员函数所作用的对象

class Complex{
public:
    double real,imag;
    void print(){
        cout<<real<<","<<imag<<endl;
    }
    Complex(double r,double i):real(r),imag(i){}

    Complex AddOne(){
        this->real++;
        this->print();
        return *this;
    }
protected:
private:
};

int main(){
    Complex a(4,5),b(1,2);
    b=a.AddOne();

    cout<<"学习c++"<<endl;
    return 0;
}

具体实例

class this_pointer{
public:
    void hello(){
        cout<<"一起学习c++"<<endl;
    }
protected:
private:
    int i;
};

int main(){
    this_pointer *p=NULL;
    p->hello();
}

输出
这里写图片描述

class this_pointer{
public:
    void hello(){
        cout<<"一起学习c++"<<i<<endl;
    }
protected:
private:
    int i;
};

int main(){
    this_pointer *p=NULL;
    p->hello();
}

程序出错

注意：静态成员函数不能使用this指针，因为静态函数不具体作用于某个对象。
因此静态成员函数中参数的个数，就是程序中写出的参数的个数

常量对象

  • 常量对象
    如果不希望某个对象的值被改变，则定义该对象的时候在前面加上const 关键字 
class Demo{
public:
    void SetValue(){}
protected:
private:
    int value;
};

const Demo obj;
  • 常量成员函数

在类的成员函数后面加上const关键字，即成为常量成员函数
常量成员函数在执行期间不修改其所作用对象，因此，常量成员函数中不能修改成员变量（静态成员变量除外），也不能调用非常量成员函数（静态成员函数除外）。

class Sample{
public:
    int value;
    void GetValue() const;
    void func(){};
    Sample(){};
protected:
private:
};

void Sample::GetValue() const{
    value=0;//wrong
}
  • 常量成员函数的重载

两个成员函数，名字和参数表一样，但一个是const，一个不是，算函数重载

public:
    CTest(int i=1):n(i){}
    int getValue(){
        return n;
    }
    int getValue() const{
        return 2*n;
    }
protected:
private:
    int n;
};

int main(){
    const CTest a;CTest b;
    cout<<a.getValue()<<"--"<<b.getValue()<<endl;
}

这里写图片描述

  • 常引用

例1：

class Time{
public:
    Time(int,int ,int);
    void print();
    void reset(Time t);
protected:
private:
    int year;int month;int day;
};

Time::Time(int a,int b,int c){
    year=a;month=b;day=c;
}

void Time::print(){
    cout<<year<<"/"<<month<<"/"<<day<<endl;
}

void Time::reset(Time t){
    t.year=0;t.month=0;t.day=0;
}

int main(){
    Time t1(1,2,3);
    t1.print();
    t1.reset(t1);
    t1.print();
}

这里写图片描述

例2：

class Time{
public:
    Time(int,int ,int);
    void print();
    void reset(Time &t);
protected:
private:
    int year;int month;int day;
};

Time::Time(int a,int b,int c){
    year=a;month=b;day=c;
}

void Time::print(){
    cout<<year<<"/"<<month<<"/"<<day<<endl;
}

void Time::reset(Time &t){
    t.year=0;t.month=0;t.day=0;
}

int main(){
    Time t1(1,2,3);
    t1.print();
    t1.reset(t1);
    t1.print();
}

这里写图片描述

例:3：

class Time{
public:
    Time(int,int ,int);
    void print();
    void reset(const Time &t);
protected:
private:
    int year;int month;int day;
};

Time::Time(int a,int b,int c){
    year=a;month=b;day=c;
}

void Time::print(){
    cout<<year<<"/"<<month<<"/"<<day<<endl;
}

void Time::reset(const Time &t){
    t.year=0;t.month=0;t.day=0;
}

int main(){
    Time t1(1,2,3);
    t1.print();
    t1.reset(t1);
    t1.print();
}

编译出错
因为const长引用，不允许修改其变量
1>e:\学校\找工作\leetcode\leetcode\leetcode\leetcode.cpp(36): error C3490: 由于正在通过常量对象访问“year”，因此无法对其进行修改
1>e:\学校\找工作\leetcode\leetcode\leetcode\leetcode.cpp(36): error C3490: 由于正在通过常量对象访问“month”，因此无法对其进行修改
1>e:\学校\找工作\leetcode\leetcode\leetcode\leetcode.cpp(36): error C3490: 由于正在通过常量对象访问“day”，因此无法对其进行修改

顺其自然__
关注
类和对象提高
及时总结
02-12 299
程序设计与算法（三）C++面向对象程序设计-郭炜 第三周 总结整理： 目录： this指针 静态成员 成员对象和封闭类 友元 friends 常量成员函数 1.this指针 C++程序到C程序的翻译 class CCar { public: int price; void SetPrice(int p); }; voi...
生成封闭类对象构造析构函数调用顺序
Gl_Zhang的博客
10-25 1444
生成封闭类对象构造析构函数调用顺序 当封闭类对象生成时1 S1：执行所有成员对象的构造函数 S2：执行封闭类的构造函数 成员对象的构造函数调用顺序 和成员对象在类中的说明顺序一致 与在成员初始化列表中出现的书序无关 当封闭类的对象消亡时 S1：先执行封闭类的析构函数 S2：执行成员对象的析构函数 先构造的后析构，后构造的先析构 #include &lt;iostream&gt; using na...
封闭类的复制构造函数
m0_62387059的博客
03-06 279
封闭类的对象，如果是用默认复制构造函数初始化的，那么它里面包含的成员对象，也会用复制构造函数初始化。 class A { public: A() { cout << "default" << endl; } A(A & a) { cout << "copy" << endl;} }; class B { A a; }; int main() { B b1,b2(b1); return 0; } 输出： default C
关于该封闭类的复制构造函数问题
qq_45586976的博客
04-22 366
【关于该封闭类的复制构造函数问题】 在上面的图片中，我们可以看到封闭类中定义了一个复制构造函数，而这个复制构造函数是怎么调用的呢？ 经过调试发现，函数在构造对象b2时调用了A类的自定义的无参构造函数 那是因为在构造b2时，首先先初始化b2中的类的成员对象a，而a并非通过复制构造的形式进行初始化的，没有提供相应的参数，所以直接调用了A类的自定义的无参构造函数。 #include <iost...
封闭类构造函数和析构函数的执行顺序
m0_62387059的博客
03-06 774
1.封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。 2.对象成员的构造函数调用次序和对象成员在类中的说明次序一致，与它们在成员初始化列表中出现的次序无关。 3.当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。 封闭类实例 class CTyre { public: CTyre() { cout << "CTyre contructor" << endl; } ~CTyre
void out3() const 问题
Gussss的博客
04-23 948
转 int main() { using namespace std; class aa { int num; public: aa() { int b = 10; num = b; }; void out1() { cout << num << endl; } void out2() const { cout ...
C++面向对象03【1.this指针 2.静态成员变量 3.成员对象和封闭类 4.各种常量 5.友元】
DurianCoriander的博客
05-14 206
摘要：1.this指针 2.静态成员变量 3.成员对象和封闭类 4.各种常量 5.友元
C++:对象，类和模板
最新发布
contest_away的博客
12-09 912
类关键字 类名函数方法区成员属性区类的定义就是对象类型的定义 ，在C语言中结构体也是类型的定义，因为C++在某些场景下会调用C库，所以可在C++中使用结构体语法，然而值得注意的区别：1.类名就是类型名类型短（只在C语言中是需要typedef重命名的）2.类中可以定义函数，声明函数不同类的属性不同，函数方法间可重载——成员函数名不用加前缀名同一个类内，不要传对象地址——成员函数函数首个形参为this指针，可以隐式传参类struct class ：机构体strut类结构体。
C++知识点总结.doc
10-07
9. **常量对象和常量成员函数**：常量对象不能修改，常量成员函数保证不修改对象的状态，常量对象可以调用常量成员函数，但常量成员函数不能调用非静态的非常量成员函数。 10. **封闭类**：包含其他对象作为成员的...
C++笔记
demon_deliver的博客
10-16 144
Effective C++ https://blog.csdn.net/weixin_43165083/article/details/91347900 深度探索C++对象模型 https://blog.csdn.net/Zy_05_11/article/details/85068490 正文: new初始化一个二维数组 int(*num)[4] = new int[2][4]; vector初始...
C++ const修饰类函数的参数
黑脚印 DarkSpoor
01-14 817
类函数与const关键字 定义一个类的函数时，const 可以出现的位置： const① ReturnType& FunctionName(const② ClassType& para) const③ 修饰函数返回值 修饰函数的参数 修饰函数 定义一个Point类 class Point { private: int x; int y; public: Point(int col = 0, int row = 0) : x(co...
个人编程笔记 - C++ 中的 const
极客BIM工作室
08-21 411
const 在 C++ 中很重要，也很基础，在实际编码中以及面试中都会被问到。下面做些总结，仅仅从我自己的角度出发，因为 const 本身已经被很多人都做了非常透彻的总结了。
Effective C++笔记之三：尽可能使用const
草上爬的博客
03-04 2516
关键字const多才多艺。你可以用它在classes外部修饰global或namespace(见Effective C++笔记之二) 作用域中的常量，或修饰文件、函数、或区块作用域(block scope)中被声明为static的对象。你也可以用它修饰classes内部的static和non-static成员变量。面对指针，你也可以指出指针自身、指针所指物，或两者都(或都不)是con...
C++中常量成员函数
hou09tian的博客
08-14 7991
可以将C++中类的成员函数声明为常量，这种成员函数叫做常量成员函数（const member function）。 1 声明 将const关键字放在类成员函数的参数列表之后，表示该函数为常量成员函数。 class MyClass { public: int consFunc() const; private: int m_MyNum; }; 2 定义 可以在类内定义cons...
C++ Const关键字
Kg_St的博客
03-14 1181
Const关键字 const 是constant 的缩写，本意是不变的，不易改变的意思。在 C++ 中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。 1.用const修饰成员变量 普通变量 const 常量，只能赋值一次。 const int num = 111;//合法 num = 222;//报错，不能给常量赋值 指针变量 只有一个const时，如果const位于*的左侧，表示指针所指的数据是常量，不能通过该指针修改实际数据，指针本身是变量，可以指向其他内存单元。 int n
CSDN-markdown
youngDoo的博客
04-21 265
Array与普通数组、链表的区别　　 >STL中的array与普通数组的区别在于它有更完备的机制，更安全，更方便，鲁棒性强，如越界检查等，此外有更多的属性和方法，功能更全面。而vector是一种动态数组，其大小在运行期间确定，可以扩充，内容存储在堆上
C++中的const
SHLYYY
02-21 1300
const前言0x00 const修饰变量0.0 const与无参宏比较0.1 const常量必须赋初值0.2 const常量在编译期间值替换0.3 const全局变量0x01 const修饰指针1.0 常量指针与指针常量1.1 const指针的相互转换1.2 const指针初始化1.3 小试牛刀0x02 const修饰引用0x03 const在class中的作用3.0 const成员变量和成员对象3.1 const成员函数3.2 const对象 前言 const关键字其实在C中就有，C中的const可
C++中的mutabel关键字
hou09tian的博客
09-25 513
mutable关键字一般在C++的类中使用，表示可变数据成员。可变数据成员可以在类的const成员函数中被修改。 1 类的const成员函数 类的const成员函数不能修改类的成员变量，声明const成员函数的方法是在函数的小括号之后加入const修饰符。 classA { public: inti{ 0 }; voidfunc()const{ } }; 其中，func是类A的const成员函数。如果在func()函数中修改i的值， voidfunc()c...
C++面向对象：this指针与类对象实例
"面向对象编程中的类与对象以及this指针的使用" 在C++中，类与对象是实现面向对象编程（OOP）的核心概念。类是用户自定义的抽象数据类型，它封装了数据成员（变量）和函数成员（方法），这体现了数据封装这一重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值