C++ 特性 -封装

已于 2022-05-09 11:04:11 修改
阅读量602 收藏
点赞数
分类专栏： 深度编程 文章标签： c++ 开发语言
于 2022-05-03 21:39:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61819021/article/details/124561747
版权

编译器：redpanda Dev.cpp.6.7.5

目录

1.1类和对象

1.2封装-权限：

1.3利用public接口实现对私有权限内容的读写操作：

1.4对象的初始化与清理：

1.4.1构造函数的分类及其调用：

1.4.2 深拷贝与浅拷贝：

1.5 初始化列表：

2.1 静态成员

2.1.2 成员变量和成员函数是分开存储的

2.1.3  this 指针的作用

2.1.4 空指针调用成员函数

2.1.5 const 修饰成员函数

2.1.6全局函数作为友元，在类内声明全局函数并用friend 关键字代表他是友元

2.1.7类和对象做友元

2.1.8成员函数做友元

1.1类和对象

封装属性和行为作为整体

class typename{
      admission://public,protected,private;
      属性：
      .......
      行为函数：
      ......
};
int main(){
     typename  ....  //实例化instantiate

}

1.2封装-权限：

公共权限： public：成员类内可以访问，类外也可以访问

保护权限： protected：成员类内可以访问，类外不可以访问，儿子可以访问父亲中的保护权限内容。

私有权限 ： private：成员雷内可以访问，类外不可以访问，儿子不可以访问父亲中的私有权限内容。C++类内不声明，默认权限是私有

#include<bits/stdc++.h>
using namespace std;
#define PI 3.14
class Person{
	public:
	string name;	
    protected :
	string car;			
	private: 
	int password;	
	public:
	void init(){
	name="ULL_64";
	car="bigG";
    password=124324;	
	} 	  
};
signed main(){
    Person p1;
    p1.init();
    cout<<p1.name<<endl;
  //cout<<p1.car<<endl;//protected  error
   //cout<<p1.password<<endl;//protected error
	return 0;
}

1.3利用public接口实现对私有权限内容得读写操作：

成员函数设置为私有的优点

1>可以自行控制读写权限;

2>对于写可以检测数据的有效性。

#include<bits/stdc++.h>
using namespace std;
#define PI 3.14
class Person{
public :
	setname(string s){
		name=s;
	}
	string getname(){
		return name;
	}
	int getage(){
		return age;
	}
    string getlover(){
		return lover;
	}
	void setage(int x){
        if(x<0||x>150)
       {
          cout<<"你这个老妖精！"<<endl;
          return ;
        }
		age=x;
	}
	void setlover(string s){
	    lover=s;
	}
private:
    string name;
    int age;
    string lover;
    
};
signed main(){
    Person p1;
    p1.setname("EX艾雷王！");
    p1.setage(1000);
    p1.setlover("EX雷德王！");
    cout<<p1.getname()<<endl;
    cout<<p1.getage()<<endl;
    cout<<p1.getlover()<<endl;
	return 0;
}

1.4对象的初始化与清理：

构造函数与析构函数

构造函数的作用：初始化；

1.没有返回值不用写void

2.函数名与类名相同

3.构造函数可以有函数，可以发生重载

4.创建对象时，构造函数会自动调用一次。

析构函数：主要作用于对象被销毁前系统自动调用，执行一些清理工作。

1.没有返回值，不写void

2.函数名和类名相同，名称前加上~

3.析构函数不含参数，不可以发生重载

4.对象销毁前自动调用一次。

#include<bits/stdc++.h>
using namespace std;
class Person{
	public: 
	 Person(){
	 	cout<<"构造函数的调用 "<<endl;
	 }
	 ~Person(){
	 	cout<<"析构函数的调用"<<endl;
	 }
};
void test01(){
	Person p;
}
signed main(){
    Person p;
    test01();
    system("pause");return 0;
}

1.4.1构造函数的分类及其调用：

按参数：含参构造，无参构造。无参构造函数不要写括号，会被编译器认定为非类的函数。

拷贝构造函数和普通构造。

注意：匿名对象的特点，当前执行结束后就被系统释放

括号法构造

   Person p1;
   Person p2(10);
   Person p3(p2);

显示法构造：

Person p1

Person p2=Person（10）

Person p3=Person（p2）；

注意：不要用拷贝函数初始化匿名对象。

隐式转化法

Person p1=10；

Person p2=p1；

拷贝构造的调用时机：

+   使用一个已经创建完毕的对象来初始化一个新对象

+  值传递的方式给函数参数传值

+  以值的方式返回局部变量

构造函数调用规则：

1.1 编译器的默认构造函数

1.默认构造函数（无参空函数体）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数（对属性进行值拷贝）

1.2 注意事项

1.如果创建了有参构造函数，编译器就不再提供默认无参构造函数。

2.如果创建了拷贝构造函数，编译器就不再提供任何默认构造函数。

1.4.2 深拷贝与浅拷贝：

浅拷贝：简单的赋值拷贝参数，编译器进行逐个字节拷贝的是浅拷贝。

浅拷贝带来的问题是堆区的内存被重复释放

解决办法，重新写一个拷贝构造函数。

#include<bits/stdc++.h>
using namespace std;
class Person{
	public :
	int age;
	int *height;
	Person(){
		cout<<"默认构造函数"<<endl;
	}
	Person(int x,int Height){
		age=x;
		height=new int (Height);
		cout<<"有参构造函数"<<endl;
	}
	~Person(){
		if(height!=NULL){
			delete height;
			height=NULL;
		}
		cout<<"析构函数"<<endl;
	}
	Person(const Person &p){
	   cout<<"copy"<<endl;
	   age=p.age;
	   height=new int (*p.height);
	}
   	
};
void test01(){
	Person p1(10,135);
	Person p2(p1);
	cout<<p1.age<<" "<<p2.age<<endl;
	cout<<*p1.height<<" "<<*p2.height<<endl;
}
signed main(){
   	test01();

	return 0;
}

如果属性有在堆区开辟的，一定要自己实现一个拷贝构造函数。避免程序崩溃。

深拷贝：在堆去申请空间，进行拷贝操作

1.5 初始化列表：

语法：构造函数（）属性1（val1） 属性2（val2）.......{}

        类内定义Person(int a,int b,int c) : m_a(a),m_b(b),m_c(c){}    
        类外调用Person p(30,20,10);

1.6类对象作为类成员

C++中类的成员可以是另一个类的对象，我们称该成员为类对象。

当其他的类的对象作为本类成员，先构造其他类的对象在构造本类成员。

析构是结论相反。

#include<bits/stdc++.h>
using namespace std;

class Phone{
	public:
		string phonename;
		Phone(string name){
			cout<<"Phone 的构造函数"<<endl;
			phonename=name;
		}
};
class Person{
	public:
		string name;
		Phone phone;
    Person (string Name,string Phonename):name(Name),phone(Phonename){
		cout<<"Person 的构造函数"<<endl;
	   }	
};
void test01(){
   Person p("张三","iphone");
   cout<<p.name<<" take an"<<p.phone.phonename<<endl; 
}
signed main(){
   	test01();
	return 0;
}

2.1 静态成员

静态成员就是再成员变量或成员函数的前面加上static 关键字，成为静态变两

静态成员分为：

+  静态成员变量

1. 所有对象共享一份数据

2.在编译阶段分配内存

3.类内声明，类外初始化

+静态成员函数

1.所有对象共享一个函数

2.静态成员函数只能访问静态成员变量

#include<bits/stdc++.h>
using namespace std;
//静态成员函数：
//所有对象 共享同一个函数，公用所有成员变量，数据是共享的。
class Person{
  public:
    static void func(){
        m_A=100000;//静态成员函数可以访问静态成员变量
      //  m_B=100;//error 静态成员函数不能访问非静态成员变量
		cout<<"静态成员函数的调用..."<<endl;
		cout<<m_A<<endl;
	}	
	static int m_A;
	int m_B;//非静态成员变量
	private :
		static void func2(){
			cout<<"静态成员函数func2 的调用"<<endl;
		}
	
};
int Person::m_A=100;//静态成员变量的的类外初始化
void test01(){
	Person p1;
	p1.func();//通过创建对象调用静态成员函数
	Person::func();//通过类名直接调用：直接再Person作用域下调用静态成员函数。
	//Person::func2(); error 静态成员函数是有访问权限的，func2是私有的静态成员函数
}
signed main(){
	test01();
	return 0;
}

2.1.2 成员变量和成员函数是分开存储的

特性 1.只有非静态成员变量才作用再类的对象上，是类的对象上一个特有的属性

特性2.为了区分空对象占用内存的位置，每个空对象被C++编译器分配了一个字节的内存。

特性3.当类内有非静态成员变量时，以该变量的数据类型分配空间。

#include<bits/stdc++.h>
using namespace std;
class Person{
	public:
	Person(){
		ma=0;
	}	
	int ma;
	static int mb;//静态成员变量  不属于类的对象上
	static void func()	//静态成员函数 不属于类的对象上
		{
			mb=1000;
			cout<<"静态成员函数的调用，静态成员变量mb=="<<mb<<endl;
		}
};
//成员变量和成员函数是分开存储的，
//只有非静态成员变量才是属于类的对象上的，是类的对象上的特有的属性
class cube{
	public :
		int a;
};
class blank{
	// 空对象。
};
signed main(){
	blank p1;
	//为了区分空对象占用内存的位置，每个空对象被C++编译器分配了一个字节的内存。
	cout<<"sizeof p1==" <<sizeof (p1)<<endl;//sizeof p1 ==1,空对象占用内存为1字节
	cube p2;
	cout<<"sizeof p2=="<<sizeof (p2)<<endl;//sizeof p2==4,这时内存按照int a 的类型来存储
	Person p3;
	cout<<"sizeof p3=="<<sizeof (p3)<<endl;//sizeof p3==4,只有非静态成员变量才属于类的对象上
	return  0;
}

2.1.3  this 指针的作用

1>解决名称冲突问题

2>this指针指向被调用函数的对象也就是一个返回自身的指针。

#include<bits/stdc++.h>
using namespace std;
class Person{
	public:
	  //1.解决名称冲突问题
	  Person (int age,string name,string lover){
	  	m_age=age;// 或者 this->m_age=age;
	  	m_lover=lover;//this->m_lover=lover
	  	m_name=name;//this->m_name=name
	  }
	  //2.this指针指向自身。指向被调用的成员函数所属的对象
	  Person & add(Person &p){
	  	  //p1.m_age+=p.m_age
	  	  this->m_age+=p.m_age;
	  	  return *this;
	  }
	  int m_age;
	  string m_name;
	  string m_lover;
	  };
void test01(){
	Person p1(18,"ULL_64","myself");
	p1.add(p1).add(p1);
	cout<<p1.m_age<<endl<<p1.m_name<<endl<<p1.m_lover<<endl;
}
signed main(){
	test01();
	return 0;
}

2.1.4 空指针调用成员函数

隐藏在每个成员函数的内部都有一个this指针，this指针的本质是指针常量，是不允许修改的，

this:::: Person * const this

	if(this==NULL) return ;//增强代码健壮性，防止空指针出错

利用this指针增强代码健壮性，防止传入空指针时引发错误。

2.1.5 const 修饰成员函数

常函数

1>成员函数加上const后称之为常函数。

2>常函数内不可以修改成员属性

3>成员属性声明时加上mutable 后在场函数中依然可以修改

常对象

1>声明对象前加const 称该对象为常函数

2>常对象只能调用常函数

#include<bits/stdc++.h>
using namespace std;
//常函数
class Person{
	public:
		int m_a;
		mutable int m_b;
		Person (int age){
			m_a=age;
		}
		void show()const//常函数
		{
		// 	m_a=100;不合法的操作，原因，常函数是不能修改类的属性的
		 // this->m_a=100;//不合法的操作，this指针的本质是指针常量 相当于const Person *const this的指向不可修改
			m_b=100;//it makes sense since m_b is mutable and special
			cout<<m_b<<endl;
		}
        void try(){
         cout<<"just try"<<endl;
        }
	
};
//常对象 本身不允许修改属性
void test02(){
	 const Person p1(100);
	 //p1.m_a=100;//no p 无法被修改
	 p1.m_b=1000;//ok m_b is mutable
	 p1.show();//常对象只允许使用常函数
     p1.try();//no 使用非常函数会改变成员对象的属性，因此不被允许。
}


signed main(){
	test02();
	return 0;
}

2.1.6全局函数作为友元，在类内声明全局函数并用friend 关键字代表他是友元

#include<bits/stdc++.h>
using namespace std;
// 友元 关键字 friend
// 全局函数作为友元，再类内声明全局函数并用friend 关键字代表他是友元
class building {
	friend string goodguy(building &p);//告诉编译器goodguy 全局函数做友元
	public :
		string m_sittingroom="客厅";
	private:
		string m_bedroom="卧室";
};
string goodguy(building &p){
	 cout<<"your friend is trying to get your privacy"<<endl;
	 return p.m_bedroom;
}
void test01(){
	building  p1;
    cout<<goodguy(p1)<<endl;
}
signed main(){
	test01();
	return 0;
}

2.1.7类和对象做友元

#include<bits/stdc++.h>
using namespace std;
// 类和对象做友元，友元可以访问自己私有成员
class Building;
class Goodguy;
class Building {
	friend class Goodguy;
	public:
		Building ();
		string m_sittingroom;
    private:
    	string m_bedroom;
    	
};
class Goodguy{
	public:
	Goodguy();
    void visit();
	Building *building;
	//goodguy has a good friend which is building ,point *building point to it
};
Goodguy::Goodguy(){
	building= new Building ;//building=(Building*)malloc(sizeof (Building ))
}
Building::Building()
{
	m_sittingroom="客厅";
	m_bedroom="卧室";
}
void Goodguy::visit(){
	cout<<"your friend class is trying to get your privacy"<<endl;
	cout<<building->m_bedroom<<endl;
}
void test01(){
	Goodguy gg;
	gg.visit();	
}
signed main(){
	test01();
	return 0;
}

2.1.8成员函数做友元

#include<bits/stdc++.h>
using namespace std;
// 类和对象做友元，友元可以访问自己私有成员
class Building;

// 让visit1（）可以访问类内的私有成员 
// 让visit2（）不可以访问类内私有的成员
class Goodguy{
public:
	Goodguy();
    void visit();
    void visit1();
    Building *building ;
};
class Building {
	friend  void Goodguy::visit();
public:
	Building ();
	string m_sittingroom;
private:
	string m_bedroom;	
};
Goodguy::Goodguy()
{
	building =new Building ;
}
Building::Building (){
	m_sittingroom="客厅";
	m_bedroom="卧室";
}
void Goodguy::visit(){
	cout<<"your friend is trying to get your privacy"<<endl;
	cout<<building->m_sittingroom<<endl;
}
void test01(){
	Goodguy gg;
	gg.visit();
}
signed main(){
	test01();
	return 0;
}

litian355
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深入解析C++编程中类的封装特性
09-03
主要介绍了深入解析C++编程中类的封装特性,是C++入门学习中的基础知识,需要的朋友可以参考下
C++三大特性之封装
weixin_33991727的博客
09-13 173
原文地址：https://qunxinghu.github.io/2016/09/12/C++%20%E4%B8%89%E5%A4%A7%E7%89%B9%E6%80%A7%E4%B9%8B%E5%B0%81%E8%A3%85/ 什么是封装？ 封装 : 封装可以隐藏实现细节，使得代码模块化 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。 在面向对象编程上可理解为：把客观事物封装成抽...
C++：属性封装
qq_42745340的博客
02-26 447
4-1 C++属性封装之初始封装 上图：违背了面向对象的基本思想，修改如下： 上图中：age设置为1000而不能提示错误，下图中可以提示： 上图中：轮子个数只希望读而不希望写时，可以这样； 4-2 C++属性封装代码演示 #include<iostream> #include<stdlib.h> #include<string> using n...
C++属性封装代码
whatiwhere的博客
02-05 279
建立一个Student 类，含有以下信息： 1、姓名：name 2、性别：gender 3、学分（只读）:score 4、学习：study #include #include #include using namespace std; class Student { public: void setName(string _name) { m_strNam
遗传算法c++实现，封装成了类（用到了c++11特性，请用vs2013以上版本）
10-10
用于全局搜索的遗传算法，封装成了c++类，带测试文件test.cpp，可直接运行。使用这个类的时候，只需要提供染色体总数、最大进化代数、最优染色体在迭代的时候复制个数、计量适应度函数指针（支持类成员指针）。 ...
C++三大特性复习
07-13
c++期末考试理论三大特性——封装，继承，与多态复习用~。
C++第1-3章答案解析.doc
12-21
C++第1-3章答案解析 本资源摘要信息涵盖了 C++ 语言的基础知识点，包括面向...C++ 语言支持面向对象技术的抽象性、封装性、继承性和多态性等特性。C++ 语言和 Java 语言均不是一个纯正的面向对象的程序设计的语言。
C++封装的特性
qq_41804181的博客
08-07 422
在面向对象设计中，封装是指数据和实现操作的代码集中起来放在对象内部，并尽可能隐蔽对象的内部细节。对象好像是一个不透明的黑盒子，从外面是看不见的，更不能从外面直接访问或修改这些数据以及代码。我们将对象的特性称为“成员变量”，将对象的行为成为“成员函数”，被封装的特性只能通过特定的行为去访问。 封装有两方面的含义： (1)是将有关的数据和操作代码封装在一个对象中，各个对象相互独立，互不干扰. (2)是...
C++的string与属性封装
liuzp111的专栏
12-26 1657
string#include <iostream> #include <stdlib.h> #include <string> using namespace std; int main(void) { string name; cout << "please input uername:"; getline(cin,name); if(name.empty())
C++特性——封装
love10_1314的博客
07-01 165
众所周知，C语言是一门面向过程的语言，而我们的C++则是面向对象的语言（OPP，面向对象的思想）,而但凡是面向对象的语言都会具有封装、继承、多态这三个特性，当然C++也具有上述这三个特性，今天我们先来总结一下这三大特性之一的封装特性。 相比于C语言，C++引入了类和对象的概念，类中提供了3个访问限定符： public 共有访问限定符 该类允许在任意位置调用（访问） private 私有...
C++三大特性之一：封装
huang714的专栏
02-27 278
C++三大特性:封装,继承,多态 对象:存在属性和行为 封装: 1.将属性和行为作为一个整体,表现生活中的事物 2.将属性和行为加权限控制 private 语法: class 类名{ 访问权限:属性/行为} //=== 封装意义一：将属性和行为写在一起表示事物 #include<iostre...
c++特性--封装
exgjdbb的博客
09-13 362
c++特性--封装
c++封装
肉丸不肉
10-23 470
1、封装 c++c是通过类来实现封装的，把这些数据和数据有关的操作封装在一个类中，或者说类的作用就是把数据和算法封装在用户声明的抽象数据类型中。 2、限定符 public：公共的 private：私有的 protected：受保护的 3、封装实例#include<iostream>   #include <stdlib.h>   #include <string>   using nam
c++初级 之 c++的封装性
zealice的博客
08-24 1423
c++作为面向对象的程序语言，有三大特性：封装性、继承性、多态性。 此篇说明封装性：什么是封装？自己的理解就是将很多同类事物（比如狗类）的共同特性（名字、颜色、跑、叫、吃）封装起来，然后遇到一个该类事物（一只具体的狗）时，就可以直接使用从该类事物封装好的这些特性。用类和对象来讲，就是：类封装了所有同类对象的一些共同特性（每个对象都有的属性（数据成员）和方法（成员函数））；实例化一个类的对象后，该
C++三大特性--封装
m0_52095916的博客
08-16 180
C++封装
C++属性封装之初始封装
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
02-13 334
面向对象的基本思想： 以谁做什么来表达程序的逻辑，以对象为中心，对象的所有行为都通过调用自己的函数来完成。体现在代码层面就是数据成员调用自己的函数以及通过函数来对自己进行操作.   封装的好处： 1.可以在成员函数中做一些必要的限制 2.有时候确实不允许用户改变数据成员 3.对数据的封装一般用set来对函数赋值 get函数用来读取数据成员   1.类的写法一般是public写在前面
c++ 封装特性的使用
最新发布
07-15
C++中的封装特性是通过类来实现的，它能够将数据和操作封装在一起，以便于更好地组织和管理代码。封装可以隐藏实现细节，提供对外部的接口，实现数据的安全访问。 在C++中，封装特性主要通过访问控制修饰符来实现，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

litian355

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

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

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

打赏作者

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

抵扣说明：

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

余额充值