子类对象调用父类的成员,结构体中

构造函数

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;

   }

};

C++中的类和目的的包装及函数实例讲明,封装实例批注

一,类的定义及包裹

1.如何是包裹

率先层意思:封装是面向对象程序设计最基本的特征。把数据(属性)和函数(方法)合成一个完完全全,那在Computer世界中是用类和目标达成的。(把质量和章程进行李包裹装)

第二层含义:把客观事物封装成抽象的类,并且类能够把温馨的习性和章程只让可信赖的类依旧目的操作,对不可靠的开展新闻的隐身。(对质量和艺术开展访谈调控)

2.类的访谈调整

在C++中得以对类的性质和形式定义访问品级,public修饰的习性和方法,能够在类的里边访谈,也得以在类的外表进行拜望。private修饰的属性和议程,只可以在类的当中开展拜望。

3.类的含义

类是把品质和章程进行包装,同临时常间对类的质量和措施开展访谈调整。

类是由大家依据客观事物抽象而成,产生一类东西,然后用类去定义对象,产生那类事物的切实个体。

类是七个数据类型,类是空洞的,而指标是四个实际的变量,是占领内部存款和储蓄器空间的。

4,圆类的抽象和包装

# include

using namespace std;

/* 抽象叁个圆类,并对圆的性质和方法开展封装 */class Circle

{

private:

double r; /* 圆类的半径属性 */

public:

void setR(double r) /* 设置圆的半径 */

{

this->r = r;

}

double getR() /* 获取圆的半径 */

{

return this->r;

}

};

二,构造函数

1.前言

当大家创造三个对象的时候,日常须要做一些开始化操作,举个例子属性进行赋初值。为了缓慢解决那么些难题,C++编写翻译器提供了构造函数来管理目的的初阶化。构造函数是一种新鲜的分子函数,与另外成员函数不相同,无需顾客来调用它,而是在创造对象时自动推行。

2.构造函数的概念及调用方式

概念:C++类中能够定义与类名同样的特别规成员函数,这种与类名同样的积极分子函数叫做构造函数。构造函数能够有参数列表,可是不能够有函数重临值。

调用:平常景况下C++编写翻译器会活动调用构造函数,但在有的景色下则供给手工业调用构造方法。

3.构造函数的归类

无参构造函数:构造函数未有函数参数。

有参构造函数:构造函数有函数参数。

拷贝构造函数:构造函数的参数为const ClassName &vriable。

4.无参构造函数示例及调用

# include

using namespace std;

/* 抽象一个圆类,并对圆的习性和艺术举办封装 */class Circle

{

private:

double r; /* 圆类的半径属性 */

public:

Circle() /* 无参构造函数 */

{

cout << "无参构造函数被施行" << endl;

}

void setR(double r) /* 设置圆的半径 */

{

this->r = r;

}

double getR() /* 获取圆的半径 */

{

return this->r;

}

};

int main()

{

/* 无参构造函数的调用格局 */

Circle circle1,circle2;

}

5.有参构造函数示例及调用

# include

using namespace std;

/* 抽象二个圆类,并对圆的属性和措施开展封装 */class Circle

{

private:

double r; /* 圆类的半径属性 */

public:

Circle(int a,int b) /* 有参构造函数 */

{

cout << "有参构造函数被调用" << endl;

}

void setR(double r) /* 设置圆的半径 */

{

this->r = r;

}

double getR() /* 获取圆的半径 */

{

return this->r;

}

};

int main()

{

/* 有参构造函数调用格局一 */

Circle circle1(1, 2);

/* 有参构造函数调用方式二:技术员手工直接调用构造方法 */

Circle circle2 = Circle(1, 2);

}

6.拷贝构造函数示例及调用

1.拷贝构造函数的调用方式

当用对象1初叶化对象2的时候拷贝构造函数被调用。

当用对象1括号办法开头化对象2的时候拷贝函数被调用。

当用对象(此处是因素而而非指针或引用)做函数参数的时候,实参传递给形参的进度会调用拷贝构造函数。

当用对象(此处是因素而而非指针或引用)做函数重回值的时候,若用同一档期的顺序来抽出该再次来到值,则会进行拷贝构造函数(此时会涉及到佚名对象的去和留的主题素材,因为函数的回来对象是个无名氏对象)。

2.拷贝构造函数调用格局示例

# include

using namespace std;

class Location

{

private:

int x;

int y;

public:

Location()

{

cout << "无参构造函数被推行" << endl;

}

Location(int x,int y)

{

this->x = x;

this->y = y;

cout << "有参构造函数被实行" << endl;

}

Location(const Location& location)

{

this->x = location.x;

this->y = location.y;

cout << "拷贝构造函数被施行" << endl;

}

~Location()

{

cout << "x = " << this->x << ",y = " << this->y << "析构函数被实践" << endl;

}

};

/* 模拟拷贝构造函数调用格局三 */void setLocation(Location location)

{

cout << "setLocation()全局函数..." << endl;

}

/* 模拟拷贝构造函数调用情势四 */

Location getLocation()

{

cout << "getLocation()全局函数..." << endl;

Location location(100, 200);

return location;

}

/* 探讨拷贝构造函数的调用 */int main()

{

/* 拷贝构造函数调用格局一 */

cout << "###############方式一###############" << endl;

Location loc1(1, 2);

Location loc2 = loc1;

/* 拷贝构造函数调用方式二 */

cout << "###############方式二###############" << endl;

Location loc3(10, 20);

Location loc4(loc3);

/* 拷贝构造函数调用方式三 */

cout << "###############方式三###############" << endl;

Location loc5(5, 10);

setLocation(loc5);

/* 拷贝构造函数调用方式四 */

cout << "###############方式四###############" << endl;

/* getLocation()发生佚名对象赋值给loc6后,无名氏对象实行析构函数,然后对象销毁 */

Location loc6;

loc6 = getLocation();

/* getLocation()发生无名对象赋值给loc7,无名氏对象被扶正,直接转成新对象 */

Location loc7 = getLocation();

}

7.构造函数小结

当类中从来不概念任何构造函数的时候,C++编译器默以为大家定义四个无参构造函数,函数体为空。

当在类中定义猖獗构造函数后(包罗拷贝构造函数),C++编写翻译器就不会为我们定义默许构造函数,约等于说大家定义了构造函数就必须要使用。

C++暗中认可提供拷贝构造函数是指向的浅拷贝。只是举办了简易的分子变量的值的复制。

拷贝构造函数唯有当我们写了今后C++编写翻译器才不会给自己提供,假设不写则C++编译器会一向提供暗中同意的正片构造函数。

三,析构函数

1.析构函数的定义及调用格局

概念:C++类中能够定义一个破例的积极分子函数来清理对象和自由大家在指标中分红的内存,那么些离奇的不二诀要叫做析构函数。

调用:当对象生命周期邻近停止时,析构函数由C++编写翻译器自动调用。

2.析构函数的采纳

析构平常是在对象生命周期结束以前调用,大家会在那儿去放活大家在目的中创建的堆内部存款和储蓄器,有限辅助程序的合理。

# define _CRT_SECURE_NO_WARNINGS

# include

using namespace std;

class Student

{

private:

char * name;

int age;

public:

Student(char * name, int age)

{

/* 在构造函数中分配堆内存 */

this->name = (char *)malloc(sizeof(name)+1);

/* 开首化成员变量 */

strcpy(this->name, name);

this->age = age;

cout << "构造函数被试行..." << endl;

}

~Student()

{

if (this->name != NULL)

{

/* 在析构函数中放出堆内存 */

free(this->name);

this->name = NULL;

this->age = 0;

}

cout << "析构函数被实施..." << endl;

}

void print()

{

cout << this->name << " = " << this->age << endl;

}

};

int main()

{

Student stu("王刚", 21);

stu.print();

return 0;

}

四,七个目的的构造函数和析构函数

1.指标开首化列表

当大家有三个类成员,它自身是三个类,何况这么些成员唯有一个带参数的构造函数,未有暗许构造函数,那年要对那个类成员实行早先化,就务须调用那一个类成员的带参构造函数,那一年可以在概念成员的时候使用该构造函数早先化对象,可是大家想要动态的最早化,则须求将该成员动态接受外部数据,由此现身了目的起始化列表这么些概念。

2.类中成员为const修饰

当大家有个类成员,它被const修饰,那么在起初化的时候可以一向在概念变量的时候初步化,也足以在运用对象开头化列表的时候举行初叶化。

3.指标初阶化示例

按 Ctrl+C 复制代码

按 Ctrl+C 复制代码

4.构造函数和析构函数的推行各类

当类中有成员是其他类的对象时,首先调用成员变量的构造函数,调用顺序和成员变量的定义顺序一致。成员变量的构造函数统统实践完结后,再调用该类的构造函数。

析构函数的实践种种是“倒关”的主意,即先与构造函数的实践顺序相反。

五,拷贝构造函数的深拷贝和浅拷贝

1.拷贝构造函数的施行原理

拷贝构造函数有三种调用情势,当大家不写拷贝构造函数的时候,C++默许的帮大家写了拷贝构造函数,其函数体实现的是大致的分子变量的值的正片。这种暗中认可的正片情势,大家誉为浅拷贝,即只是轻巧的复制作而成员变量的值到另多少个指标中。

2.深拷贝问题的抛出

当我们的成员变量是动态分配的一组堆内部存款和储蓄器的时候,那个时候C++暗许的为大家写的正片构造函数把成员变量的值进行了复制,那么副本也会针对原始对象所分配的堆内部存款和储蓄器,当大家在析构函数中自由堆内部存款和储蓄器的时候,就能生出四次析构现象(二回是本来对象释放堆内部存款和储蓄器,贰遍是别本对象释放堆内部存款和储蓄器)因而导致程序崩溃。

3.深拷贝代码示例

# define _CRT_SECURE_NO_WARNINGS

# include

using namespace std;

class Student

{

private:

char * name;

int age;

public:

/* 无参构造函数 */

Student()

{

cout << "无参构造函数被施行..." << endl;

}

/* 有参构造函数 */

Student(char * name, int age)

{

/* 在构造函数中分红堆内部存储器 */

this->name = (char *)malloc(sizeof(name) + 1);

/* 初步化成员变量 */

strcpy(this->name, name);

this->age = age;

cout << "有参构造函数被推行..." << endl;

}

/* 拷贝构造函数 */

Student(const Student &student)

{

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

this->name = (char *)malloc(sizeof(student.name) + 1);

/* 开头化成员变量 */

strcpy(this->name, name);

this->age = age;

cout << "拷贝构造函数被推行..." << endl;

}

/* 析构函数 */

~Student()

{

if (this->name != NULL)

{

free(this->name);

this->name = NULL;

this->age = 0;

}

cout << "析构函数被试行..." << endl;

}

void print()

{

cout << this->name << " = " << this->age << endl;

}

};

int main()

{

Student stu1("王刚", 22);

/* 此时拷贝构造函数执行,在创造别本的时候实行深拷贝,则不会油但是生析构难题 */

Student stu2 = stu1;

return 0;

}

一,类的定义及封装 1.什么是封装 第一层含义:封装是面向对象程序设计最核心的...

//基类中      承袭形式            子类中

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++编写翻译器...

class Teacher {

public:

char *name;

int age;

public:

Teacher(char *name, int age) {

this->name = name;

this->age = age;

cout << "有参构造函数" << endl;

}

//拷贝构造函数

//暗许拷贝构造函数,便是值拷贝

Teacher(const Teacher &obj) {

this->name = obj.name;

this->age = obj.age;

cout << "拷贝构造函数" << endl;

}

void myprint() {

cout << name << "," << age << endl;

}

};

上边说一下友元函数,成效在于,能够透过这么些函数,访问类中定义的个人变量

class Human{

public:

Human(char* name, int age){

this->name = name;

this->age = age;

cout << "Human 构造函数" << endl;

}

~Human(){

cout << "Human 析构函数" << endl;

}

void say(){

cout << "说话" << endl;

}

protected:

char* name;

int age;

};

class Teacher{

private:

char *name;

int age;

public:

//无参构造函数赋暗中认可值

Teacher(){

this->name = malloc;

strcpy(name,"jack walson");

age = 20;

cout << "无参构造函数" << endl;

}

//析构函数

//当对象要被系统释放时,析构函数被调用

//作用:善后管理

~Teacher(){

cout << "析构" << endl;

//释放内部存款和储蓄器

free(this->name);

}

};

void func(){

Teacher t1;

}

void main(){

func();

system;

}

Teacher *t1 = new Teacher("jack"); 来代表在堆内部存款和储蓄器中,创制贰个指针。并且用delete去放活掉那块内部存款和储蓄器

能够看见,继承的时候,其实是有 访谈修饰符 的,这里举三个表

能够看看,这里面就重写了拷贝构造函数,其作用,和不写是一致的。原因前面说了,那是暗许便是值拷贝,这里的写法,也是值拷贝。

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;

};

//protected  & private继承 = > private

很简短,跟JAVA其实差不离

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");

}

class Student : public Person, public Citizen{

};

析构函数就是作善后甩卖的函数,如下

能够看看,可以直接通过类名访谈静态变量/静态方法

//

那般,当对象被系统释放时,析构函数也会被调用

第一在A中,申请友元类B,然后在B中,定义A为个人成员,就能够调用A成的成员变量了!!

//public    & public继承 = > public

如上一向赋值,在JAVA中,t1,t2打字与印刷出来都以直接的,都是会yan。而在此处,独有t1是yan,t2的打字与印刷,照旧会是rose。所以能够看来,这里的正片,是值拷贝,并不是指向指针。其效果同样下边包车型客车写法:

//静态属性开始化赋值

//男人

在类中,是足以定义方法的,且类中,能够有this,直接针对变身的变量,这些在结构体中,都以不设有的。

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

//承袭的二义性

末尾打印出的正是,无参,有参,有参

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

加以下 构造函数与析构函数调用的逐一,上面包车型客车例证中,在最初化子类时,也会给父类赋值

本文由必威发布于必威-编程,转载请注明出处:子类对象调用父类的成员,结构体中

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。