Menu

美高梅开户中的类和对象实例讲解,类的一些基本操作

C++中的类和对象实例批注,对象实例解说

一,对象的动态建设构造和刑释

1.哪些是指标的动态构造建设和假释

一般来说我们成立的对象都以由C++编写翻译器为大家在栈内部存储器中创设的,我们鞭长莫及对其张开生命周期的军事管制。所以大家要求动态的去建设构造该对象,由此大家需求在堆内部存款和储蓄器中创建对象和假释对象。在C语言中为大家提供了malloc()函数和free()函数来为我们提供在堆内部存款和储蓄器中分配变量的措施,可是在C++中引进了new和delete关键字来让大家动态的创制和释放变量。

2.new和delete关键字

new关键字是用来在堆内部存款和储蓄器中创制变量的,格式为:Type * ptr = new
Type(常量/表明式);
其参数列表中的常量/表明式可以用来给变量初步化,也能够省略不写。其重返结果为该项目的指针。借使内部存款和储蓄器分配失败则赶回空指针。

delete关键字是用来释放用new关键字创制的内部存款和储蓄器,格式为delete
ptr(释放数组必得需求加中括号,delete [] ptr)。

3.new和delete关键字与malloc和free的差异

new关键字在分配内部存款和储蓄器的时候,会基于其创立的参数调用相应的类的构造函数。delete关键字会在释放内部存款和储蓄器在此之前,会率先调用类的析构函数释放对象中定义的内部存款和储蓄器。

malloc和free关键字不会去调用类的构造函数和析构函数。

4.new和delete关键字示例

# define _CRT_SECURE_NO_WARNINGS

# include

using namespace std;

class Teacher

{

public:

char * name;

int age;

public:

/* 无参构造函数 */

Teacher()

{

name = NULL;

age = 0;

cout << “无参构造函数被试行…” << endl;

}

/* 有参构造函数 */

Teacher(char * name, int age)

{

/* 在构造函数中分配堆内部存款和储蓄器 */

this->name = new char[sizeof(name) + 1];

/* 早先化成员变量 */

strcpy(this->name, name);

this->age = age;

cout << “有参构造函数被实施…” << endl;

}

/* 拷贝构造函数 */

Teacher(const Teacher &student)

{

/* 重新分配内部存款和储蓄器 */

this->name = new char[sizeof(name) + 1];

/* 伊始化成员变量 */

strcpy(this->name, name);

this->age = age;

cout << “拷贝构造函数被施行…” << endl;

}

/* 析构函数 */

~Teacher()

{

if (this->name != NULL)

{

delete [] this->name;

this->name = NULL;

this->age = 0;

}

cout << “析构函数被实践…” << endl;

}

};

int main()

{

/* 创建int变量,并释放 */

int * a = new int;

int * b = new int(100);

delete a;

delete b;

/* 创建double变量,并释放 */

double * c = new double;

double * d = new double(10.1);

delete c;

delete d;

/* 创立数组并释放 */

char * e = new char[100];

delete [] e;

/* 创造对象并释放 */

Teacher * stu1 = new Teacher(“王刚”,22);

cout << “姓名:” << stu1->name << “,年龄:” <<
stu1->age << endl;

Teacher * stu2 = new Teacher();

delete stu1;

delete stu2;

/* 利用malloc和free创立对象,不能调用其布局和析构函数*/

Teacher * stu3 = (Teacher *)malloc(sizeof(Teacher));

free(stu3);

}

二,静态成员变量和静态成员函数

1.static关键字

static关键字用来声称类中的成员为静态属性。当用static关键字修饰成员后,该类所开创的指标分享static成员。无论创造了不怎么个目的,该成员只有一份实例。静态成员是与类相关的,是类的一种表现,而不是与该类的靶子相关。

2.静态成员的概念

静态成员是类具备的目的的分享成员,并不是有个别对象的积极分子,它在对象中不占用存款和储蓄空间,那一个成员属于全数类,而不属于现实的三个对象,所以静态成员变量无法在类的个中开展开首化,必得在类的表面实行早先化。举例定义一个学员类,那么学生对象总量能够注明为static,在构造方法中,对该变量进行加1,进而总计学生对象的多寡。

3.静态成员变量总计

静态成员变量能够用static关键字定义,可是起首化必得在类的外侧举办初阶化。

静态成员变量可以被类及类的指标所访问和退换。

静态成员变量遵守类的访谈调整原则,假如为private修饰,则只好够在类的内部和在类外面早先化的时候访谈,不会再被其余措施访谈。

4.静态成员函数计算

静态成员函数用static关键字定义,在静态成员函数中得以访谈静态成员变量和静态成员函数,但不允许访谈普通的分子变量和分子函数,因为平时的积极分子属于对象而不属于类。档案的次序不均等。可是在日常成员中得以访问静态成员。

当静态成员函数在类中定义,可是在类的外侧完成的时候,没有必要再加static关键字。

静态成员函数未有this指针。

5.静态分子重视总结

静态成员是类和类的目的的全部者,因而静态成员变量不可能在类的中间开展起始化,必得在类的表面进行初阶化。

静态成员依然依据private,protected,public的访谈调节原则。

静态成员函数中一贯不this指针,不可能访问普通的分子变量和成员函数,能够访谈静态成员变量和分子函数,不过足以因而传递对象的不二法门访谈普通成员。

6.静态成员变量演示

# include

using namespace std;

class MyStudent

{

private:

static int count;/* 学生对象总量 */

char name[64];

int age;

public:

static int n;

public:

MyStudent(char * name,int age)

{

strcpy(this->name, name);

this->age = age;

MyStudent::count++;/* 学生数量加1 */

}

void getCount()/* 普通成员函数访谈静态成员变量 */

{

cout << “学生总量:” << MyStudent::count << endl;

}

};

/* 静态成员变量初阶化 */int MyStudent::count = 0;

int MyStudent::n = 10;

int main()

{

/* 测量试验静态成员变量 */

MyStudent student1(“王刚”,22);

student1.getCount();

/* 对象和类格局采访静态成员变量 */

student1.n = 100;

MyStudent::n = 200;

}

7.静态分子函数演示

# include

using namespace std;

class Test

{

private:

int m;

public:

static int n;

public:

void setM(int m)

{

this->m = m;

/* 访谈静态成员函数 */

test();

}

public:

static void xoxo();

static void test()

{

n = 100;

// m = 10; 不允许访问普通成员变量

// int c = getM(); 不允许访谈普通成员函数

// this->m = 一千; this指针不设有

cout << “static void test()函数…” << endl;

}

};

/* 起首化静态成员 */int Test::n = 10;

/* 类中宣称,类外达成 */void Test::xoxo()

{

cout << “static void Test::xoxo” << endl;

}

int main()

{

Test t;

/* 普通成员函数访谈静态成员函数 */

t.setM(10);

/* 成员函数的调用格局 */

t.test();

Test::test();

}

?三,友元函数和友元类

1.友元函数

当我们定义类的时候,使用private关键字修饰成员变量(成员函数),那样产生了访谈调整。有个别时候,大家须要让部分函数来拜候对象的个人成员(属性或情势),C++为大家提供了友元函数那几个定义,所谓的友元函数就是指这些函数是这几个类的好恋人,允许让这么些函数访谈这几个类创造的目的的私家属性和民用方法。友元函数用friend函数来声称,友元函数的宣示必得在类的在那之中,友元函数的完成一定要在类的外表(假如友元函数的兑现也在里头,那还要用友元函数干什么?),友元函数的宣示地方与访谈调整符毫无干系。

2.友元函数示例

# include

using namespace std;

/* 定义点类 */class Point

{

private:

int x;

int y;

/* 友元函数的概念:求两点的偏离 */

friend int distance(Point &p1, Point &p2);

public:

Point(int x, int y)

{

this->x = x;

this->y = y;

}

};

/* 友元函数的兑现 */int distance(Point &p1, Point &p2)

{

int dx = p1.x – p2.x;

int dy = p1.y – p2.y;

return sqrt(dx*dx + dy*dy);

}

int main()

{

Point p1(3, 4);

Point p2(0, 0);

int dis = distance(p1, p2);

cout << “点(3,4)到原点的相距为:” << dis << endl;

}

3.友元类

若B类是A类的友元类,则B类的有所成员函数都以A类的友元函数。类B能够访谈类A的有着私有品质和艺术。

友元类经常被设计为一种对数据操作如故类之间传递音讯的帮扶类。

4.友元类示例

# include

using namespace std;

/* 定义类A */class A

{

private:

int x;

friend class B;/* 定义类B为类A的友元类 */private:

void setX(int x)

{

this->x = x;

}

};

/* 定义类B */class B

{

private:

A AObj;

public:

/* 类B的有所成员函数都是类A的友元函数,由此都能够访谈类A的私房属性和艺术
*/

void operater(int tmp)

{

AObj.setX(tmp);

}

void display()

{

cout << “类A的村办属性x = ” << AObj.x << endl;

}

};

int main()

{

B b;

b.operater(100);

b.display();

return 0;

}

一,对象的动态创立和释放 1.如何是目的的动态创设和假释
经常大家创制的指标都以由C++编写翻译器…

经过new(delete)动态内部存款和储蓄器分配

class Teacher{

   private:

   char* name;

   public:

   Teacher(char* name){

      this->name = name;

      cout << “Teacher有参构造函数” << endl;

 }

~Teacher(){

      cout << “Teacher析构函数” << endl;

}

void setName(char* name){

      this->name = name;

}

char* getName(){

      return this->name;

     }

};

void func(){

   //C++

   //会调用构造和析构函数

   Teacher *t1 = new Teacher(“jack”);

   cout << t1->getName() << endl;

   //释放

   delete t1;

   //C

   //Teacher *t2 = (Teacher*)malloc(sizeof(Teacher));

   //t2->setName(“jack”);

   //free(t2);

}

void main(){

   func();

   //数组类型

   //C

   //int *p1 = (int*)malloc(sizeof(int) * 10);

   //p1[0] = 9;

   //free(p1);

   //C++

   int *p2 = new int[10];

   p2[0] = 2;

   //释放数组 []

   delete[] p2;

   system(“pause”);

}

能够看到,C++这里更加的像JAVA了

Teacher *t1 = new Teacher(“jack”);
来代表在堆内部存款和储蓄器中,制造多个指南针。並且用delete去自由掉那块内部存款和储蓄器

static 静态属性和章程

class Teacher{

   public:

   char* name;

   //计数器

   static int total;

    public:

    Teacher(char* name){

        this->name = name;

        cout << “Teacher有参构造函数” << endl;

}

~Teacher(){

      cout << “Teacher析构函数” << endl;

}

void setName(char* name){

     this->name = name;

}

char* getName(){

    return this->name;

}

//计数,静态函数

static void count(){

    total++;

   cout << total << endl;

  }

};

//静态属性开始化赋值

int Teacher::total = 9;

void main(){

Teacher::total++;

cout << Teacher::total << endl;

//直接通过类名访谈

Teacher::count();

//也得以透过对象名访问

Teacher t1(“yuehang”);

t1.count();

system(“pause”);

}

能够见到,能够向来通过类名访谈静态变量/静态方法

上面说一下友元函数,效率在于,能够经过这么些函数,访谈类中定义的私家变量

class A {

  //友元函数

   friend void modify_i(A *p, int a);

   private:

   int i;

   public:

   A(int i) {

      this->i = i;

   }

~A() {

cout << “析构” << endl;

   }

void myprint() {

cout << i << endl;

   }

};

//友元函数的贯彻,在友元函数中能够访问私有的品质

void modify_i(A *p, int a) {

   p->i = a;

}

void main() {

   A* a = new A(10);

   a->myprint();

   modify_i(a, 20);

   a->myprint();

   delete a;

   system(“pause”);

}

如上格局,就能够变动类中的私有变量的值,况且例子中采纳到了C++中的动态内部存款和储蓄器,以及动态内部存款和储蓄器的自由的

下边说下友元类,说白了,就是友元类能够访谈自身的类成员!!

class A {

//友元类

friend class B;

private:

int i;

public:

A(int i) {

this->i = i;

}

void myprint() {

cout << i << endl;

}

};

class B {

   public:

   //B那几个友元类能够访谈A类的另外成员

   void accessAny() {

      a.i = 30;

}

private:

   A a;

};

率先在A中,申请友元类B,然后在B中,定义A为私家成员,就足以调用A成的成员变量了!!

标签:,

发表评论

电子邮件地址不会被公开。 必填项已用*标注

相关文章

网站地图xml地图