亲宝软件园·资讯

展开

C++数据共享与保护

风云诀4 人气:0

1.作用域

作用域是一个标识符在程序正文中有效的区域

作用域关系从大到小为:

命名空间作用域 > 类作用域 > 局部作用域

标识符的有效范围就是标识符的可见性,可见性的一般规则为:

2.对象生存期

如果对象生存期与程序的运行期相同,则它具有静态生存期

局部生存期对象诞生于声明点,结束于声明所在块执行完毕之时

void f()
{
	static int m=0;	//m仅在f中能访问 
	m++;
	cout<<m<<endl;
}

静态数据成员

如果某个属性为整个类所共有,可以采用static关键字来声明为静态成员。

class A{
public:
	static int m; 
};
int A::m=20;			//在类外进行初始化 
int main(){
	A a,b;
	a.m=10;			    //可以赋值 
	cout<<a.m<<endl;
	cout<<b.m<<endl;	//两者的值相同
}

静态成员函数

class A{
public:
	static void f(A a);
	static void g(){
		cout<<"hello"<<endl;
	}
	void fun(){
		cout<<"world"<<endl;
	}
private:
	int x;
	static int y;
};
int A::y=10;
void A::f(A a){
	cout<<a.x<<endl;    //必须通过对象名访问
	cout<<y<<endl; 		//直接访问该类的静态数据成员 
	g();				//直接访问该类的静态成员函数 
}
int main(){
	A a;
	A::f(a);            //直接通过类名调用
	return 0; 
}

3.类的友元

友元关系是一种数据共享机制,通过友元关系,一个普通函数或者类中的成员函数可以访问封装于另外一个类中的数据

为了确保数据的完整性和封闭性,建议尽量少地使用友元

友元函数

友元函数是类中用关键字friend修饰的非成员函数,在它的函数体中可以通过对象名访问类的private和protected成员

class A{
public:
	friend int main();
private:
	int x;
};
int main(){
	A a;
	a.x=5;	//访问 private对象 
}

友元类

若B类为A类的友元类,则B类的所有成员函数都是A类的友元函数,都可以访问A类的private和protected成员

class A{
public:
	friend class B;
private:
	int x,y;
	void f(){
		cout<<x<<endl;
	} 
};
class B{
public:
	void print(){
		a.x=5;
		a.y=10;
		cout<<a.y<<endl;//可以访问A类对象的私有成员 
		a.f();			//可以访问A类对象的私有函数 
	}
private:
	A a;
}; 

注意(!!!)

1.友元关系是单向的。

B类是A类的友元,B能访问A的私有数据,但A不能访问B的私有数据

2.友元关系不能传递。B是A的友元,C是B的友元,C和A之间如果没有声明就不存在友元关系

3.友元关系不能被继承。 

4.共享数据的保护

常对象

数据成员值在对象的整个生存期间不能被修改的对象叫做常对象,一般用const进行修饰

常对象必须进行初始化,而且不能被更新

声明常对象的语法形式为:

const 类型说明符 对象名;

class A{
public:
	A(int i,int j):x(i),y(j){···}
private:
	int x,y;
};
int main(){
	const A a(3,4); //a为常对象,不能被更新 
}

常成员函数

使用const关键字修饰的函数为常成员函数

语法:

类型说明符 函数名(参数表)const;

如果将一个对象说明为常对象,通过该常对象只能调用它的常成员函数,不能调用其他函数(常对象唯一的对外接口方式)

class A{
public:
	A(int i,int j):x(i),y(j){···}
	void print(){
		cout<<x<<" "<<y<<endl;
	}
	void print() const{
		//常成员函数
		cout<<x<<" const "<<y<<endl;
	}
private:
	int x,y;
};
int main(){
	A a(1,2);
	a.print();  //调用 void print() 
	const A b(3,4);
	b.print();  //调用 void print() const 
}

使用const说明的数据成员为常数据成员

类中说明了常数据成员,任何函数不能对它赋值,构造函数对它进行初始化只能通过初始化列表

class A{
public:	
	//常数据成员只能通过构造函数的初始化列表来获得初值 
	A(int i):a(i){···}
private:
	const int a;       //常数据成员
	static const int b;//静态常数据成员
};
const int A::b=10;  //静态常数据成员在类外初始化 

常引用

如果在声明引用时用const修饰,被声明的引用就是常引用,常引用所引用的对象不能被更新

常引用的声明形式:

const 类型说明符 & 引用名;

一个常引用,无论是绑定到一个普通对象,还是一个常对象,通过该引用访问该对象时,都只能把该对象当做常对象

class Point{
public:
	Point(int x,int y):x(x),y(y){}
	friend float dist(const Point &p1,const Point &p2);
private:
	int x,y;
};
float dist(const Point &p1,const Point &p2){   //常引用作形参
	double x=p1.x-p2.x;
	double y=p1.y-p2.y;
	return sqrt(x*x+y*y);
}
int main(){
	const Point m1(1,1),m2(4,5);
	cout<<dist(m1,m2)<<endl;    //两点间距离 
}

Tips

extern int n;//声明一个在其他文件定义的外部变量n

对于外部函数,加不加 extern 效果都是一样的

如果在定义变量和函数时使用static关键字,可以让该变量和函数无法被其他编译单元引用

运算符new的功能是动态分配内存,语法形式为

new 数据类型(初始化参数列表)

对于基本数据类型,如果不希望在分配内存后设立初值,可以把括号省去

int* point = new int;

如果保留括号,但括号中不写任何数值,则表示用0来进行初始化

int* point = new int( );

运算符delete用来删除由new建立的对象,释放指针所指向的内存空间,格式为:

delete 指针名;

用new分配的内存,必须用delete加以释放,否则会造成“内存泄漏”,而且只用delete进行一次删除,对同一内存空间多次使用delete进行删除会导致运行错误

用new创建一维数组时,在方括号后加或者不加小括号的区别和“new T( )”一样,用delete删除时在指针名前面要加“[ ]”

int* p = new int[100]; //不设置初值
int *p = new int[100] ( ); //用0进行初始化
delete[ ] p;

默认复制构造函数,进行的是浅复制,对指针复制后会出现两个指针指向同一个内存空间的情况,内存空间会被析构函数释放两次,导致运行错误

解决这一问题必须要自己定义复制构造函数,使复制后的对象指针成员有自己的内存空间,即进行深复制,这样就避免了内存泄漏发生。

class A{
public:
	void display(int x){
		this->x=x;   //前一个x为数据成员,后一个x为形参
	}
private: 
	int x;
};

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!  

加载全部内容

相关教程
猜你喜欢
用户评论