C++学习笔记（五）

最新推荐文章于 2024-01-30 16:07:33 发布
最新推荐文章于 2024-01-30 16:07:33 发布
阅读量398 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45445740/article/details/111402158
版权

目录五

十五.this指针和常成员函数

1.this指针

#include <iostream>
#include <cstring>
using namespace std;
class Dummy{
public:
    Dummy(const char* str)
        //:m_str(str),m_len(m_str.size()){}
        //:m_str(str),m_len(strlen(str)){}
        :m_str(str?str:""),
         m_len(strlen(str?str:"")){}
    size_t m_len;
    string m_str;
};
int main(void){
    //Dummy d("hello");
    Dummy d(NULL);
    cout << d.m_str << "," << d.m_len << endl;

    return 0;
}

①类中的成员函数(包括构造函数、析构函数)中都隐藏一个该类类型指针参数，名为this；在成员函数中访问类中的其它成员，其本质都是this来实现的。
②对于普通成员函数，this指向调用对象的地址；如果对于构造函数，this指向正在创建的对象地址。
③大多数情况可以忽略this，在成员函数宏直接访问类中的其它成员，但是以下几个特殊场景必须要使用this指针：
–》区分作用域 eg.this->m_name = m_name;
eg.

#include <iostream>
using namespace std;
class Teacher{
public:
    /*
    Teacher(const string&name,int age,double sal)
        :m_name(name),m_age(age),m_sal(sal){
        cout << "构造函数:" << this << endl;    
    }*/
    //当参数变量和成员变量名字相同时,可以通过
    //this区分,通过this所访问到的一定是成员变量
    Teacher(const string& m_name,int m_age,
            double m_sal){
        this->m_name = m_name;
        this->m_age = m_age;
        this->m_sal = m_sal;
    }
    void print(void){
        cout << m_name << "," << m_age << "," << m_sal << endl;
        cout << this->m_name << ","<< this->m_age << "," << this->m_sal << endl;
    }/*编译器处理后:
    void print(Teacher* this){
        cout << this->m_name << ","<< this->m_age << "," << this->m_sal << endl;
    }*/
private:
    string m_name;
    int m_age;
    double m_sal;
};
int main(void){
    Teacher t1("小明",45,8000);
    Teacher t2("小张",46,9000);
    t1.print();//Teacher::print(&t1)
    t2.print();//Teacher::print(&t2)

    cout << "&t1=" << &t1 << endl;
    cout << "&t2=" << &t2 << endl;

    return 0;
}

–》从成员函数返回调用对象自身(返回自引用)（重点掌握）
eg.

#include <iostream>
using namespace std;
class Counter{
public:
    Counter(int count=0):m_count(count){}
    Counter& add(void){
        ++m_count;
        //this指向调用对象,*this就是调用对象自身
        return *this;//返回自引用
    }
    void print(void){
        cout << "计数值:" << m_count << endl;
    }
private:
    int m_count;
};
int main(void){
    Counter c;
    c.add().add().add();
    c.print();//3
    return 0;
}

–》从类的内部销毁对象自身(对象自销毁)
eg.

#include <iostream>
using namespace std;
class Counter{
public:
    Counter(int count=0):m_count(count){}
    Counter& add(void){
        ++m_count;
        //this指向调用对象,*this就是调用对象自身
        return *this;//返回自引用
    }
    void print(void){
        cout << "计数值:" << m_count << endl;
    }
    void destroy(void){
        cout << "this:" << this << endl;
        delete this;//对象自销毁
    }
private:
    int m_count;
};
int main(void){
    Counter* pc = new Counter;
    pc->add();
    pc->print();//1
    //delete pc;
    cout << "pc:" << pc << endl;
    pc->destroy();
    return 0;
}

–》作为成员函数的实参，实现不同对象之间的交互（了解），这种代码可读性差
eg.

#include <iostream>
using namespace std;
class Student;//短视声明
class Teacher{
public:
    void educate(Student* s);
    void reply(const string& answer);
private:
    string m_answer;
};
class Student{
public:
    void ask(const string& q,Teacher* t);
};
void Teacher::educate(Student* s){
    //通过this指针,将教师对象地址传给学生对象
    s->ask("什么是this指针?",this);//1)
    cout << "学生回答:" << m_answer << endl;//5)
}
void Teacher::reply(const string& answer){
    m_answer = answer;//4)
}
void Student::ask(const string& q,Teacher* t){
    cout << "问题:" << q << endl;//2)
    t->reply("this就是指向调用对象的地址");//3)
}
int main(void){
    Teacher t;
    Student s;
    t.educate(&s);
    return 0;
}

2.常成员函数

①在一个成员函数参数表的后面加const，这个成员函数就是常成员函数(常函数)。

返回类型 函数名(形参表) const {函数体}

eg.

#include <iostream>
using namespace std;
class A {
public:
    A(int data = 0) :m_data(data) {}
    //void print(const A* this)
    void print(void) const {//常成员函数
        //cout << this->m_data++ << endl;
        cout << m_data/*++*/ << endl; //这里使用m_data++是错误的，因为加了const

        //const_cast<A*>(this)->m_spec = 200;
        m_spec = 200;
        cout << m_spec << endl;
    }
private:
    int m_data;
    mutable int m_spec;
};
int main(void) {
    A a(100);
    a.print();//100
    a.print();//若const，则输出m_data++，结果为101
    return 0;
}

②常成员函数中this指针是一个常指针，不能在常成员函数中直接修改成员变量的值。
（注：被mutable修饰的成员变量，可以在常成员函数直接修改）
③非常对象既可以调用非常函数也可以调用常函数；但是常对象只能调用常函数，不能调用非常函数（重点掌握）
（注：常对象也包括常指针和常引用）
eg.

#include <iostream>
using namespace std;
class A{
public:
    //void func1(const A* this)
    void func1(void) const {
        cout << "常函数" << endl;
        //func2();//this->func2()
    }
    //void func2(A* this)
    void func2(void){
        cout << "非常函数" << endl;
    }
};
int main(void){
    A a;
    a.func1();//A::func1(&a),A*
    a.func2();//A::func2(&a),A*
    const A a2 = a;
    a2.func1();//A::func1(&a2),const A*
    //a2.func2();//A::func2(&a2),const A*

    const A* pa = &a;//pa:常指针
    pa->func1();
    //pa->func2();
    
    const A& ra = a;//ra:常引用
    ra.func1();
    //ra.func2();

    return 0;
}

④同一个类中，函数名和参数表相同的成员函数，其常版本和非常版本可以构成有效的重载关系；常对象匹配常版本，非常对象匹配非常版本。
eg.

#include <iostream>
using namespace std;
class A{
public:
    void func(void)const{
        cout << "func常版本" << endl;    
    }
    void func(void){
        cout << "func非 常版本" << endl;
    }
};
int main(void){
    A a;
    a.func();//非 常版本
    const A a2 = a;
    a2.func();//常版本
    return 0;
}

十六.析构函数(Destructor)

1.语法

class 类名{
		~类名(void){
			//主要负责清理对象生命周期中的动态资源
		}
};

①函数名一定是"~类名"
②没有返回类型，也没有参数
③不能被重载，即一个类只能有一个析构函数

2.当对象被销毁时，析构函数将自动被调用

①栈对象离开所在作用域时，析构函数被作用域终止的右花括号（ } ）调用。
②堆对象的析构函数被delete操作符调用。
（注：delete对象时，会自动调用析构函数，在释放对象自身的内存，而如果是free函数只会释放自身内存不会调用析构函数）
eg.

#include <iostream>
using namespace std;
class Integer{
public:
    Integer(int i):m_pi(new int(i)){
        //m_pi = new int(i);
    }
    void print(void) const {
        cout << *m_pi << endl;
    }
    ~Integer(void){
        cout << "析构函数" << endl;
        delete m_pi;
    }
private:
    int* m_pi;
};
int main(void){
    if(1){
        Integer i(100);
        i.print();//100
        cout << "test1" << endl;
        Integer* pi = new Integer(200);
        pi->print();//200
        delete pi;//->析构函数
        cout << "test3" << endl;
    }//->析构函数
    cout << "test2" << endl;
    return 0;
}

3.如果一个类自己没有定义析构函数，那么编译器将会为该类提供一个缺省的析构函数

①对于基本类型的成员变量，什么也不做。
②对于类类型的成员变量(成员子对象)，将会自动调用相应类的析构函数。

4.对象创建和销毁的过程（重要）

①创建
–》分配内存
–》构造成员子对象(按声明的顺序)
–》执行构造函数代码
②销毁
–》执行析构函数代码
–》析构成员子对象(按声明的逆序)
–》释放内存

eg.

#include <iostream>
using namespace std;
class A{
public:
    A(void){
        cout << "A的构造函数" << endl;
    }
    ~A(void){
        cout << "A的析构函数" << endl;
    }
};
class B{
public:
    B(void){
        cout << "B的构造函数" << endl;
    }
    ~B(void){
        cout << "B的析构函数" << endl;
    }
    A m_a;//成员子对象
};
int main(void){
    B b;
    return 0;
}

十七.拷贝构造和拷贝赋值

1.浅拷贝和深拷贝

①如果类中包含了指针形式的成员变量，缺省的拷贝构造只是复制了指针变量自身，而没有复制指针所指向的内容，这种拷贝方式被称为浅拷贝。
②浅拷贝将会导致不同对象之间的数据共享，如果数据在堆区，析构时还可能会引发"double free",导致进程终止，所以就必须自定义一个指针复制指针所指向内容的拷贝构造函数，即深拷贝。
在这里插入图片描述
eg.

#include <iostream>
using namespace std;
class Integer{
public:
    Integer(int i):m_pi(new int(i)){
        //m_pi = new int(i);
    }
    void print(void) const {
        cout << *m_pi << endl;
    }
    ~Integer(void){
        cout << "析构函数:" << m_pi << endl;
        delete m_pi;
    }
    //缺省的拷贝构造函数(浅拷贝)
    /*Integer(const Integer& that){
        cout << "缺省的拷贝构造函数" << endl;
        m_pi = that.m_pi;
    }*/
    //自定义拷贝构造函数(深拷贝)
    Integer(const Integer& that){
        cout << "自定义拷贝构造函数" << endl;
        m_pi = new int;
        *m_pi = *that.m_pi;
    }
private:
    int* m_pi;
};
int main(void){
    Integer i1(100);
    Integer i2(i1);//拷贝构造
    i1.print();//100
    i2.print();//100
    return 0;
}

练习

①实现字符串类(String),里面包括构造函数、析构函数、拷贝构造函数。

class String{
public:
		//构造函数：支持const char*字符串
		String(const char* str = NULL){}
		//析构函数
		~String(void){}
		//拷贝构造函数
		String(const String& that){}
		//打印
		void print(void)const{
			cout << m_str << endl;
		}
private:
		char* m_str;
};

eg.

#include <iostream>
#include <cstring>
#pragma warning( disable : 4996 ) 
using namespace std;

class String 
{
public:
	//构造函数：支持const char*字符串：动态分配内存
	String(const char* str = NULL)
	{
		m_str = new char[strlen(str ? str : "") + 1]; //防止str是空的字符串，就会报错;动态分配内存，在原有字符串长度基础上＋1
		strcpy(m_str, str ? str : "");//字符串拷贝赋值操作，同样防止str为空的情况
	}

	//析构函数：主要负责清理对象生命周期中的动态资源
	~String(void)
	{
		//cout << "析构函数：" << &m_str << endl;
		cout << "析构函数：" << (void*)m_str << endl; // 打印delete的地址
		if (m_str) // 若字符串是空的则跳过，若不是空的则要释放内存
		{
			delete[] m_str; //因为申请的内存是char[]，则释放时是delete[]
			m_str = NULL;
		}
	}

	//拷贝构造函数
	String(const String& that)
	{
		m_str = new char[strlen(that.m_str) + 1];
		strcpy(m_str, that.m_str);
		//*m_str = *that.m_str; //这么写相当于只复制了字符串中的第一个元素，与11copy.cpp里面不一样，那里是int类型
	}

	//打印函数
	void print(void)const
	{
		cout << m_str << endl;
	}

private:
	char* m_str;
};

int main(void)
{
	String str("buding");
	str.print();
	String str2 = "duoduo";
	str2.print();
	return 0;
}

②

#include <iostream>
using namespace std;
class B{
private:
    int data;
public:
    B(){
        cout << "defalt constructor" << endl;
    }
    ~B(){
        cout << "destructor" << endl;
    }
    B(int i):data(i){
        cout << "constructed by parameter:" 
            << data << endl;
    }
    B(const B& that){
        cout << "copy constructor" << endl;
    }
};
B Play(B b){
    return b;
}
int main(int argc,char** argv){
    B temp = Play(5);
    return 0;
}
//问题1:程序结果是什么?为什么是这个结果
//答：constructed by parameter:5
//    copy constructor
//    destructor
//    destructor
//问题2:B(int i):data(i),这种语法专业术语叫什么? 
//答：初始化列表
//问题3:Play(5),形参类型是类,而5是个常量,这样写合法么?为什么?
//答：合法，意思是先把5作为b对象，即相当于B b=5;
boss-dog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++中为什么存在this指针？
w903414的博客
10-09 1770
在这篇文章中 初识类和对象，谈到了类的初步认识和基本操作方法。 成员函数存储在公共的代码段，不同的对象调用成员函数时候，那么编译器如何知道具体操作的是哪一个对象呢？ 在这里就引出了this指针。 C++编译器给每个 “非静态的成员函数” 增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过这个指针来完成的。只不过所有的操作对用户来说都是透明的，不需要用户来传递，编译器自动完成。       this指针特性： 只
类中非静态成员函数中的----this指针
小葱的博客
02-15 4318
首先思考一下在c++中，编译器是如何识别一个类的？ 识别一个类可以分为一下三步？ ①识别类名； ②识别数据成员； ③识别成员函数并将其改写。 引出的问题：类中的数据成员相当于全局变量，但是全局变量在使用之前，必须先定义，而类中的数据成员的位置可以任意，这就是因为识别类时的顺序而导致的区别。我们都知道类中成员函数和数据成员的存储方式： 类的大小包括非静态数据成员而不包括成员函数
c++this指针 返回对象本身
qq_53079283的博客
05-09 495
为了在成员函数中能够方便地引用该对象自身的成员变量或方法，C++提供了一个指向当前对象的指针，即this指针。this指针指向的是当前对象的地址，因此可以通过this指针访问当前对象的成员变量或方法。在上述代码中，类Student中的setName和setAge方法都返回了*this指针，即当前对象的指针，以便可以链式调用这两个方法，并且可以在链式调用中方便地操作对象的多个属性。在C++中，如果在成员函数中需要返回当前对象自身，可以使用this指针返回本身，即返回当前对象的指针。
C++ 非静态成员函数中隐含的this指针
CodeHouse的博客
07-21 1450
#include <iostream> using namespace std; /************************************************************************ 由于成员函数不占用对象空间大小，非静态成员函数只会诞生一份函数实例，多个同类型对象共用一块代码 如何区分哪个对象调用自己的呢 this指针隐含在每一个非静态成员函数内，指向被调用成员函数所属的对象 this指针用途 1.当形参和数据成员变量同名时，可以使用thi
C++ 类的介绍
qinshaang的博客
09-26 273
一.类的定义   在面向对象程序设计中，类就是具有相同的数据和相同的操作的一组对象的集合，也就是说，类是对具有相同的数据结构和相同操作的一类对象的描述。   在C++中把类的数据成为数据成员，类的操作使用函数来实现的。类与对象的关系就是抽象与具体的关系，类是多个对象进行综合抽象的结果，一个对象是类的一个实例。 二.类类型声明的一般形式 class 类名 { [private:] 私有数据成员...
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记
04-01
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。
C++——this指针
勇气是明知不可为而为之
07-07 1143
this指针是C++中的一个特殊指针，它指向当前对象的地址。在类的成员函数中，this指针可以用来访问当前对象的成员变量和成员函数。this指针的作用是区分同名的成员变量和局部变量，以及在成员函数中访问其他成员函数。
this指针及const成员函数
一个菜鸟
07-29 1524
每个成员函数都有一个额外的、隐含的形参将改成员函数与调用该成员函数的类对象绑定在一起。这个而外的形参就是this，在调用成员函数时，形参this初始化为调用函数的对象的地址。 const成员函数的使用： double avg_price() const;该声明就是一个cons
C++对象模型和this指针，const修饰成员函数详解
最新发布
2301_79431343的博客
01-30 757
空对象占用内存空间为1字节，这样是为了区分不同的空对象占内存的位置使得每个空对象都有一个独一无二的内存地址。
【C/C++】用return返回一个函数
m0_61629312的博客
08-13 292
2023年8月13日，周日早上。我的第一篇使用了动态图的博客。
C/C++编程：类
OceanStar的博客
03-10 1260
类是一种用户定义类型。 语法： 类关键词：class、struct、union 之一
C++学习——类和对象
我爱吃香锅的博客
11-01 272
类：是一种实体的抽象类型 类的引入 在C++面向对象编程(OPP)中，类即为通过对实体属性、行为等特征的抽象产生的一种实体抽象类型。将其属性定义为成员变量，其行为定义为成员方法(成员函数)，通过对类的实例化产生各种各样对象进而实现面向对象的编程思想。 类的定义 class className { // 类体：由成员函数和成员变量组成 }; // 一定要注意后面的分号 clas...
2.C++变量和基本类型
qq_75055369的博客
03-11 337
本章知识点是讲述内置类型和一些更复杂的数据类型
C++this指针的用途
m0_51955470的博客
01-25 3109
this指针的用途： 1.当形参和成员变量同名时，可用this指针来区分。 2.在类的非静态成员函数中返回对象本身，可使用return *this 每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，那么问题是： 这一块代码是如何区分哪个对象调用自己的呢？ C++通过提供特殊的对象指针，this指针解决上述问题。 对象p1,p2,p3都要调用这个函数，怎么区分是谁调用的呢？ 用this指针解决这个问题 this指针指向被调用的成员函数所属的对象 简单来说，谁调用这个函数，th
对象返回自身
weixin_41377572的博客
02-15 437
#include <iostream> #include <cstring> using namespace std; class Test{ public: Test(int a,int b){ this->m_a=a; this->m_b=b; } void print(){ cout<<"m_a: "<<this-...
C++ 类this及返回自身对象的引用看这一篇就明白
u014339447的博客
11-04 7174
C++ 类this及返回自身对象的引用看这一篇就明白this及返回自身对象的引用 this及返回自身对象的引用 this:调用成员函数的时候，编译器负责把对象地址传（&myTime）递给成员函数中隐藏的this形参。 在系统角度来看，任何对类成员的直接访问都是被this隐式调用的。 this有个const修饰符，只能用来指向已确定的那个对象，不能更改。 this只能在成员函数中使用，全局函数静态函数不能使用this。 在成员普通函数中，this是一个指向非const对象的const指针。（this
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

boss-dog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值