c++封装，六大函数和static_c++ 封装c函数

C和C++

1.C+调用C语言：

extern "C"

{

包含在里面的代码以C语言规则来进行处理。

}

2.C++  面向对象的语言

1.类和对象：

（1）oop思想   （2）封装特性   （3）this(this call)

oop思想：模拟现实：

对象：空间+资源

成员变量 （独享）

成员方法（共享）

 2.封装：隐藏了对象的属性和实现细节，对外提供公有接口，供函数使用。【getname()接口】

访问限定符：

public: 任意

protected:本类和子类

private:本类

class Student

{

public:

std::string getName()

{

return mname;

}

std::string getId()

{

return mid;

}

int getAge()

{

return mage;

}

private:

std::string mname;

std::string mid;

int mage;

};

int main()

{

Student stu1;

stu1 getName();

return 0;

}

 

stu1.getName()

Student* const this 

调用点将对象地址传给this指针，this所指向的对象下成员变量

 

类中的6个默认函数：

1.构造函数 2.析构函数 3.拷贝构造函数 4.赋值运算符的重载函数 5.取地址操作符的重载函数 6.const修饰的取地址操作符的重载函数

构造函数：初始化对象所占的内存空间

特点：

1.可以重载

2.不依赖对象调用（是生成对象的一部分）

人为提供则系统不提供

 

class String

{

public:

String(char* ptr)

          :mptr(new char[strlen(ptr)+1]())

{

strcpy_s(mptr,strlen(ptr)+1,ptr);

}//构造函数名和类名相同

 

析构函数：释放对象所占的其他资源

特点：

1.不可重载

2.依赖对象调用

~String()

{

delete []mptr;

}

对象的生成：空间+资源    1.开辟空间 2.赋予资源

对象的销毁：1.调用析构函数：释放其他资源 2.释放空间

 

3.拷贝构造函数：

拿一个已存在的对象生成相同类型的新对象

String (const String &rhs);

1.拷贝构造函数的形参一定要是引用（防止循环生成对应的形参对象，栈满了，溢出）

2.默认：浅拷贝

成员变量有指针存在，考虑是否深拷贝

String (const String &rhs)

{

mptr=new char[strlen(rhs.mptr)+1]();

strcpy_s(mptr,strlen(rhs.mptr)+1,rhs.mptr);

}

4.赋值运算符的重载函数：

String &operator=(const String &rhs);

拿一个已存在的对象赋给相同类型的已存在对象(默认浅拷贝）

String & operator=(const String &rhs)

{

if(this!=&rhs)

{

delete[]mptr;

mptr=new char[strlen(rhs.mptr)+1]();

strcpy_s(mptr,strlen(rhs.mptr)+1，rhs.mptr);

}

return *this;

}

this指针存放的是对象地址下的成员变量

5.取地址操作符的重载函数

String* operator&()

{

return this;

}

6.const 修饰的取地址操作符重载函数

const String* operator&()const

{

return this;

}

static:

1.修饰成员变量：不属于成员变量，属于类，对象共享，在类外初始化

2.修饰成员方法：this call--->cdecl

没有this指针，不能访问普通的类成员变量和类成员方法，只能访问静态的类成员变量和类成员方法

不依赖对象

static关键字的用法：

1.变量

（1）全局变量

（2）布局变量

（3） 类成员变量

2.方法

(1)普通全局方法

(2)类成员方法

class Test

{

public:

Test(int a,int b)

     :ma(a),mb(b)

{}

static void Show()//静态成员方法

{

std::cout<<" mb:"<<mb<<std::endl;

}

private:

static int ma;//属于类，不属于对象

int mb;

}

int Test::ma=10;//类外初始化