C++ 底层分析 3.权限控制 Class

1.将定义与实现分开

将定义与实现分离，代码会有更好的可读性，但不是必须的

• xxx.h 只是一个文件，可以是任何的后缀名,如果你愿意，可以叫xxx.exe
• #include 的作用只是把里面的内容复制过来 仅此而已.
  如：#include "abc.exe
• xxx.h 与 xxx.cpp并不要求一定同名

2.public private的使用

public：这个成员哪里都可以用，不用担心被修改，所以，一旦发布成public的成员，是不能够改名字的.

private：这个成员只用于内部使用，不要在其他的地方使用.

总结：
1、对外提供的函数或者变量，发布成public的 但不能随意改动.

2、可能会变动的函数或者变量，定义成private的 这样编译器会在使用的时候做检测.

3、只有结构体内部的函数才可以访问private的成员.

4、public/private可以修饰函数也可以修饰变量.

3.private真的不能访问吗？

private只是对编译器而已，在内存里还是一样的，用指针可以随意蹂躏

struct Test					
{					
private:					
	int x;				
public:					
	int y;				
	void Init(int x,int y)				
	{				
		this->x = x;			
		this->y = y;			
	}				
};					
											
Test t;					
t.Init(1,2);					
					
					
int* p = (int*)&t;					
					
int n = *p;					
					
int m = *(p+1);					
					
printf("%d %d\n",n,m);					

总结：

private修饰的成员与普通的成员没有区别 只是编译器会检测.

private修饰的成员只有自己的其他成员才能访问

4.class与struct的区别

成员权限的区别：编译器默认class中的成员为private 而struct中的成员为public

class Base						
{						
	int x;					
	int y;					
};						
						
int main(int argc, char* argv[])						
{						
	Base base;					
						
	base.x = 10;					
	base.y = 20;					
						
	return 0;					
}						

继承中的区别：

5.private是否被继承？
答案是显然的，已经说了很多遍，private无法访问是对编译器而言，在内存中它还是一样的，所以可以通过指针访问，再次提醒了C++对于C来说加的只是编译器的限制和代码，仅此而已

class Base			
{			
public:			
	Base()		
	{		
		x = 11;	
		y = 12;	
	}		
private:			
	int x;		
	int y;		
};			
class Sub:Base			
{			
public:			
	int a;		
	int b;		
};			
			
int main(int argc, char* argv[])			
{			
	Sub sub;		
	sub.a = 1;		
	sub.b = 2;		
	
	int* p = (int*)⊂	
			
	printf("%d\n",sizeof(sub));		
	printf("%d\n",*(p+0));		
	printf("%d\n",*(p+1));		
	printf("%d\n",*(p+2));		
	printf("%d\n",*(p+3));		
			
	return 0;		
}			

总结：
1、父类中的私有成员是会被继承的

2、只是编译器不允许直接进行访问

题目：用class做一遍

MyClass.cpp

#include "stdafx.h"
#include "MyClass.h"

//
// Construction/Destruction
//


MyString::MyString(int Size)
{
	this->arr = (char*)malloc(Size);
	memset(arr,0,Size);
}
MyString::MyString()
{
	this->arr = (char*)malloc(1024);
	memset(arr,0,1024);
}
MyString::~MyString()
{
	free(arr);
	arr = NULL;
}

void MyString::SetString(char* str1)
{
	memcpy(arr,str1,strlen(str1));		
}

void MyString::PrintString()
{
	printf("%s\n",arr);
}

void MyString::AppendString(char* stradd)
{
	char* pTemparr = this->arr;
	while(*++pTemparr);
	memcpy(pTemparr,stradd,strlen(stradd));
}

int MyString::Size()
{
	return strlen(this->arr);
}

MyClass.h

#include<iostream>
#include<iomanip>

class MyString
{
	char* arr;	
public:
	~MyString();
	MyString(int Size);
	MyString();
	void SetString(char* str1);
	void PrintString();
	void AppendString(char* stradd);
	int Size();	
};

wa_0403.cpp

#include "stdafx.h"
#include "MyClass.h"

#include<cmath>
#include<iostream>
#include<iomanip>

using namespace std;

void Test()
{
	MyString mystring(1000);
	mystring.SetString("哎Mikasys");
	mystring.PrintString();
	printf("%d\n",mystring.Size());
	mystring.AppendString("爱你爱你");
	mystring.PrintString();
	printf("%d\n",mystring.Size());
}
int main()
{
	Test();
	
	return 0;
}