C++继承时派生类的成员访问属性
公用（public）：访问权限最高；除派生类外，外部函数也可以直接访问（无论是成员变量还是成员函数）。
私有（private）：访问权限最低；只能是该类内部函数互相调用，派生类、外部函数都不能访问。
保护（protect）：访问权限中间；该类内部函数、派生类都能访问，外部类、外部函数不能访问
我们这样来记会更加容易一些，在继承时： 1、不管采用哪种形式（public, protected或private），基类中的私有成员都不可以被继承；如果非要在派生类中使用基类的私有成员，可以有两种方法：一是使用属性，二是使用友元类或友元函数。
2、如果采用public形式，则基类除了私有成员的其它所有都被原样的继承到派生类中；即在基类中是public的，在派生类中还是public的，在基类中是protected的，在派生类中还是protected的。
3、如果采用protected形式，则基类中除了私有成员的其它说有都被以protected的形式继承到派生类中。
C++中的继承方式有： public、private、protected三种（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）。
（1）public（公有继承）：继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；派生类的对象只能访问基类中的public成员。
（2）private（私有继承）：继承时基类中各成员属性均变为private，并且基类中private成员被隐藏。派生类的成员也只能访问基类中的public/protected成员，而不能访问private成员；派生类的对象不能访问基类中的任何的成员。
（3）protected（保护性继承）：继承时基类中各成员属性均变为protected，并且基类中private成员被隐藏。派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；派生类的对象不能访问基类中的任何的成员。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！在C++中怎么实现对象数组按某一属性排序?_百度知道
在C++中怎么实现对象数组按某一属性排序?
比如分数高低,或是学号顺序一类的.再按这个顺序输出来.
我有更好的答案
你可以在自己的对象数组中添加一个方法,比如class student{private:public:
int comparable(student temp){
if(temp.score & this.score)
return -1;
else if (temp.score == this.score)
}}然后在比较的时候就可以根据comparable这个函数来比较大小，进行排序。如果使用stl的sort也可以指定用这个函数返回的值来判断大小。希望对你有所帮助。
采纳率：57%
#include &iostream&void input(int *arr, int n) {for (int i=0; i&n; ++i) {
cin && arr[i];}}void sort(int *arr, int n) {for (int i=0; i&n-1; ++i) {
for (int j=i+1; j&n; ++j) {
if (arr[i] & arr[j]) {
tmp = arr[i];
arr[i] = arr[j];
}}}void output(int *arr, int n) {
for (int i=0; i&n; ++i) {
cout && arr[i] && & &;
cout &&}int main(){
int arr[10];
input(arr, 10);
sort(arr, 10);
output(arr, 10);}
本回答被网友采纳
为您推荐：
其他类似问题
对象数组的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。java中静态方法,静态变量,静态初始化器,构造函数,属性初始化都是什么时候调用的? 它们的先后顺序。_百度知道
java中静态方法,静态变量,静态初始化器,构造函数,属性初始化都是什么时候调用的? 它们的先后顺序。
我有更好的答案
静态方法是你手动调用的时候执行。静态变量与类一起加载，最优先的。然后是，静态初始化器（只初始化静态成员变量）。然后是，属性初始化（只初始化非静态成员变量）。最后是，构造函数（常用的，你懂的）... 记住：先是静态，然后是非静态。
采纳率：44%
静态方法,静态变量,静态初始化器 因为是静态的
所以按照你写的顺序执行构造函数,属性都是属于实例化的东西，所以比非静态的后执行
为您推荐：
其他类似问题
静态变量的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。C++类的执行顺序？ - 知乎2被浏览284分享邀请回答0添加评论分享收藏感谢收起一，类的概念及封装
1.什么是封装
第一层含义：封装是面向对象程序设计最基本的特性。把数据（属性）和函数（方法）合成一个整体，这在计算机世界中是用类和对象实现的。（把属性和方法进行封装）
第二层含义：把客观事物封装成抽象的类，并且类可以把自己的属性和方法只让可信的类或者对象操作，对不可信的进行信息的隐藏。（对属性和方法进行访问控制）
2.类的访问控制
　　在C++中可以对类的属性和方法定义访问级别，public修饰的属性和方法，可以在类的内部访问，也可以在类的外部进行访问。private修饰的属性和方法，只能在类的内部进行访问。
3.类的意义
类是把属性和方法进行封装，同时对类的属性和方法进行访问控制。
类是由我们根据客观事物抽象而成，形成一类事物，然后用类去定义对象，形成这类事物的具体个体。
类是一个数据类型，类是抽象的，而对象是一个具体的变量，是占用内存空间的。
4，圆类的抽象和封装
# include&iostream&
using namespace
/* 抽象一个圆类，并对圆的属性和方法进行封装 */
class Circle
double /* 圆类的半径属性 */
void setR(double r) /* 设置圆的半径 */
double getR() /* 获取圆的半径 */
return this-&r;
二，构造函数
　　当我们创建一个对象的时候，常常需要做某些初始化操作，例如属性进行赋初值。为了解决这个问题，C++编译器提供了构造函数来处理对象的初始化。构造函数是一种特殊的成员函数，与其他成员函数不同，不需要用户来调用它，而是在创建对象时自动执行。
2.构造函数的定义及调用方式
定义：C++类中可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数。构造函数可以有参数列表，但是不能有函数返回值。
调用：一般情况下C++编译器会自动调用构造函数，但在一些情况下则需要手工调用构造方法。
3.构造函数的分类
无参构造函数：构造函数没有函数参数。
有参构造函数：构造函数有函数参数。
拷贝构造函数：构造函数的参数为const ClassName &vriable。
4.无参构造函数示例及调用
# include&iostream&
using namespace
/* 抽象一个圆类，并对圆的属性和方法进行封装 */
class Circle
double /* 圆类的半径属性 */
Circle() /* 无参构造函数 */
cout && "无参构造函数被执行" &&
void setR(double r) /* 设置圆的半径 */
double getR() /* 获取圆的半径 */
return this-&r;
int main()
/* 无参构造函数的调用方式 */
Circle circle1,circle2;
5.有参构造函数示例及调用
# include&iostream&
using namespace
/* 抽象一个圆类，并对圆的属性和方法进行封装 */
class Circle
double /* 圆类的半径属性 */
Circle(int a,int b) /* 有参构造函数 */
cout && "有参构造函数被调用" &&
void setR(double 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&iostream&
using namespace
class Location
Location()
cout && "无参构造函数被执行" &&
Location(int x,int y)
cout && "有参构造函数被执行" &&
Location(const Location& location)
this-&x = location.x;
this-&y = location.y;
cout && "拷贝构造函数被执行" &&
~Location()
cout && "x = " && this-&x && ",y = " && this-&y && "析构函数被执行" &&
/* 模拟拷贝构造函数调用方式三 */
void setLocation(Location location)
cout && "setLocation()全局函数..." &&
/* 模拟拷贝构造函数调用方式四 */
Location getLocation()
cout && "getLocation()全局函数..." &&
Location location(100, 200);
/* 研究拷贝构造函数的调用 */
int main()
/* 拷贝构造函数调用方式一 */
cout && "###############方式一###############" &&
Location loc1(1, 2);
Location loc2 = loc1;
/* 拷贝构造函数调用方式二 */
cout && "###############方式二###############" &&
Location loc3(10, 20);
Location loc4(loc3);
/* 拷贝构造函数调用方式三 */
cout && "###############方式三###############" &&
Location loc5(5, 10);
setLocation(loc5);
/* 拷贝构造函数调用方式四 */
cout && "###############方式四###############" &&
/* 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&iostream&
using namespace
class Student
Student(char * name, int age)
/* 在构造函数中分配堆内存 */
this-&name = (char *)malloc(sizeof(name)+1);
/* 初始化成员变量 */
strcpy(this-&name, name);
this-&age =
cout && "构造函数被执行..." &&
~Student()
if (this-&name != NULL)
/* 在析构函数中释放堆内存 */
free(this-&name);
this-&name = NULL;
this-&age = 0;
cout && "析构函数被执行..." &&
void print()
cout && this-&name && " = " && this-&age &&
int main()
Student stu("王刚", 21);
stu.print();
四，多个对象的构造函数和析构函数
1.对象初始化列表
　　当我们有一个类成员，它本身是一个类，而且这个成员只有一个带参数的构造函数，没有默认构造函数，这个时候要对这个类成员进行初始化，就必须调用这个类成员的带参构造函数，这个时候可以在定义成员的时候采用该构造函数初始化对象，但是我们想要动态的初始化，则需要将该成员动态接受外界数据，因此出现了对象初始化列表这个概念。
2.类中成员为const修饰
　　当我们有个类成员，它被const修饰，那么在初始化的时候可以直接在定义变量的时候初始化，也可以在使用对象初始化列表的时候进行初始化。
3.对象初始化示例
# include&iostream&
using namespace
/* 定义A类 */
A(int a, int b)
cout && "A(" && this-&a && "," && this-&b && ")有参构造函数被执行" &&
cout && "~A(" && this-&a && ", " && this-&b && ")析构函数被执行" &&
/* 定义类B */
const int m = 10;
/* 对象初始化列表：让成员变量从外界接收的方式来初始化 */
B(int x,int y):a1(x,y),a2(10,20),n(100)
cout && "B(int x,int y)有参构造函数被执行" &&
cout && "~B()析构函数被执行" &&
int main()
B b(1, 2);
4.构造函数和析构函数的执行顺序
当类中有成员是其他类的对象时，首先调用成员变量的构造函数，调用顺序和成员变量的定义顺序一致。成员变量的构造函数统统执行完毕后，再调用该类的构造函数。
析构函数的执行顺序是&倒关&的方式，即先与构造函数的执行顺序相反。
五，拷贝构造函数的深拷贝和浅拷贝
1.拷贝构造函数的执行原理
　　拷贝构造函数有四种调用方式，当我们不写拷贝构造函数的时候，C++默认的帮我们写了拷贝构造函数，其函数体实现的是简单的成员变量的值的拷贝。这种默认的拷贝方式，我们称为浅拷贝，即只是简单的复制成员变量的值到另一个对象中。
2.深拷贝问题的抛出
　　当我们的成员变量是动态分配的一组堆内存的时候，这个时候C++默认的为我们写的拷贝构造函数把成员变量的值进行了复制，那么副本也会指向原始对象所分配的堆内存，当我们在析构函数中释放堆内存的时候，就会发生两次析构现象（一次是原始对象释放堆内存，一次是副本对象释放堆内存）因此造成程序崩溃。
3.深拷贝代码示例
# define _CRT_SECURE_NO_WARNINGS
# include&iostream&
using namespace
class Student
/* 无参构造函数 */
cout && "无参构造函数被执行..." &&
/* 有参构造函数 */
Student(char * name, int age)
/* 在构造函数中分配堆内存 */
this-&name = (char *)malloc(sizeof(name) + 1);
/* 初始化成员变量 */
strcpy(this-&name, name);
this-&age =
cout && "有参构造函数被执行..." &&
/* 拷贝构造函数 */
Student(const Student &student)
/* 重新分配内存 */
this-&name = (char *)malloc(sizeof(student.name) + 1);
/* 初始化成员变量 */
strcpy(this-&name, name);
this-&age =
cout && "拷贝构造函数被执行..." &&
/* 析构函数 */
~Student()
if (this-&name != NULL)
free(this-&name);
this-&name = NULL;
this-&age = 0;
cout && "析构函数被执行..." &&
void print()
cout && this-&name && " = " && this-&age &&
int main()
Student stu1("王刚", 22);
/* 此时拷贝构造函数执行，在创建副本的时候进行深拷贝，则不会出现析构问题 */
Student stu2 = stu1;
阅读(...) 评论()