c++自学笔记3

时间：2015-01-26 17:07:56 阅读：164 评论：0 收藏：0 [点我收藏+]

标签：

指针是一种数据类型，是一种特殊的数据类型，具有指针类型的变量称为指针变量，指针变量存放其他变量或者对象的地址，它可以有效地表示数据之间复杂的逻辑关系。动态分配内存，方便字符串的处理，

数组名表示内存中分配给数组的固定位置，是指针常量。故不能给数组名赋值，修改了数组名，就会丢失数组空间。

new和delete是c++动态申请和删除存储单元的函数，new在创建动态对象的同时完成了初始化工作。

例如 obj *a=new obj; // 调用无参
obj *b=new obj(1); //调用有参
如果用new创建对象数组，那么只能使用对象的无参构造函数。由new申请的对象，运行结束时，必须由delete删除，在用delete释放对象数组时，注意不要丢掉[]，delete []objects;

利用指向对象的指针可以吧对象组织成链表。

this指针是隐含在对象内的一种指向自己的指针。当一个对象被创建了之后，它的每一个成员函数都可以使用this指针。当一个对象调用自己的成员函数时，系统先将该对象的地址赋值给this指针，然后调用成员函数，成员函数对成员操作时，隐含的使用了this指针。

#include<iostream>

using namespace std;

class Obj{
private:
int a,b;
public:
Obj(int x=0,int y=0){
a=x;
b=y;
}
void copyObj(Obj&);
void Display(){
cout<<"("<<a<<","<<b<<")"<<endl;
}

};
void Obj::copyObj(Obj&aObj){
this->a=aObj.a; //对象可以调用数据成员
this->b=aObj.b;
}

int main(){

Obj x1(7,9),x2(5,6);
cout<<"x1=";
x1.Display();
cout<<"x2=";
x2.Display();
x1.copyObj(x2);
cout<<"x1";
x1.Display();

return 0;
}

引用就是给一个实体变量取了一个别名，也就是说把猫叫了一个咪，两个本质还是一个，引用不重新开辟空间。一般在等号的左边，在右边就是取地址符号。

#include<iostream>

using namespace std;

void change(int &x,int &y){

int m;
m=x;
x=y;
y=m;
}
int main(){

int a=9,b=6;
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
change(a,b);
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
return 0;
}

可以在已有的类的基础上定义新类，而不需要把已有的类重新写一遍，这就是继承，派生类可以提高程序的效率，减少了冗余的代码，从而大量节省时间，

#include<iostream>

using namespace std;

class Point{
float x,y; //点的坐标
public:
Point(float a=0,float b=0){
x=a;
y=b;
}
void SetP(float a=0,float b=0){
x=a;
y=b;
}
void Display(){
cout<<"<"<<x<<"."<<y<<">"<<endl;
}
};
class Circle:public Point{
float z; //派生类的半径
public:
Circle(float c=1,float a=0,float b=0):Point(a,b){
z=c; //这个还和顺序有关，园自己的构造函数体
}
void SetC(float a=0,float b=0,float c=0){
z=c;
SetP(a,b);
};
void play(){
cout<<"圆的半径: ";
cout<<z<<endl;
cout<<"圆的位置: ";
Display();
}
};
int main(){

Circle a(8);
a.play();
a.SetC(1,2,3);
a.play();

return 0;
}

单继承就是每个派生类只有一个基类。继承的成员的访问权限
#include<iostream>

using namespace std;

class A{
private:
int i;
protected:
int j;
void show_A1(){
cout<<"A 保护显示：i="<<i<<"j="<<j<<endl;
}
public:
A(int x,int y){
i=x;
j=y;
}
void show_A2(){
cout<<"A2 在执行中。。。"<<endl;
show_A1();
cout<<"A2 执行完毕。。。"<<endl;
}
};

class B:protected A{
private:
int x;
public:
B(int i,int j,int k):A(i,j){
x=k;
}
void show_B(){
cout<<"B在执行show_A1()..."<<endl;
show_A1();//保护继承可以直接访问
cout<<"B在执行show_A2()..."<<endl;
show_A2(); //保护继承也可以间接访问公有 ,
cout<<"B公有显示: x="<<x<<endl;
cout<<"B执行完毕"<<endl;
}
};
class C:public B{
public:
C(int i,int j,int x):B(i,j,x){}//空语句，在基类中可完成初始化
void show_C(){
cout<<"C在执行show_A2()..."<<endl;
show_A2();
cout<<"C在执行show_A1()..."<<endl;
show_A1();
cout<<"C在执行show_B()..."<<endl;
show_B();
cout<<"C执行完毕"<<endl;
}

};

int main(){
B b(1,2,3);
b.show_B();
// b.show_A2(); B从A类保护继承，所以不能直接访问A类的公有成员
C c(100,200,300);
c.show_C();
cout<<"公有继承直接可以调用"<<endl;
// c.show_B();
return 0;
}

单继承的应用
#include <iostream>
#include<string.h>

using namespace std;
class people{
char name[10],sex; //姓名性别
long idnumber; //身份证号码
public:
people(long num=0,char*n="",char s=‘m‘){
idnumber=num;
strcpy(name,n);
sex=s;
} //构造函数
void p_show(){
cout<<"人员：身份证="<<idnumber;
cout<<"姓名="<<name<<" 性别= ";
if(sex==‘m‘||sex==‘M‘)
cout<<"男"<<endl;
if(sex==‘w‘||sex==‘W‘)
cout<<"女"<<endl;

}
};

class student:public people{
int s_num; //学号
public:
int s_class;
student(long n,char *na,char s=‘m‘,int sn=0,int sc=0):people(n,na,s){
s_num=sn;
s_class=sc;
} //构造函数
void s_show(){
cout<<"学生\t";
p_show();
cout<<"学号="<<s_num<<"班级= "<<s_class<<endl;
}
};

class member:public people{ //教工类公有继承people类
int m_num; //工号
public:
char department[10]; //部门
member(long n,char *na,char s=‘m‘,int mn=0,char *md="\0"):people(n,na,s){
m_num=mn;
strcpy(department,md);
}//构造函数
void m_show(){
cout<<"教工\t";
p_show();
cout<<"教工编号="<<m_num<<"单位= "<<department;
}

};

class worker:public member{
char station[10];
public:
worker(long n,char *na,char s=‘m‘,int mn=0,char *md="\0",char *st="\0"):
member(n,na,s,mn,md){
strcpy(station,st); //构造函数
}
void w_show(){
cout<<"工人\t";
m_show();
cout<<"\t岗位="<<station<<endl;//访问基类的公有成员

}
};
class teacher:public member{
char course[10]; //执教课程
public:
teacher(long n,char *na,char s=‘m‘,int mn=0,char *md="\0",char *tc="\0"):
member(n,na,s,mn,md){
strcpy(course,tc);
}
void t_show(){
cout<<"教师\t";
m_show();
cout<<"\t执教课程= "<<course<<endl;

}
};

int main(int argc, char** argv) {
people p(981102,"赵彤彤",‘w‘);
p.p_show();
student s(781010,"杜帅",‘m‘,1001,982);
s.s_show();
worker w(123456,"安妮",‘m‘,123,"计算机系","秘书");
w.w_show();
teacher t(666666,"剑姬",‘m‘,456,"计算机系","上单");
t.t_show();
cout<<"直接访问公有基类成员"<<endl;
t.m_show();
w.p_show();
cout<<t.department<<endl;//直接访问公有的数据成员

return 0;
}

从一个基类派生的继承称为单继承，从多个基类派生的称为多继承。
公有继承的特点：基类的公有成员和保护成员作为派生类的成员时，他们都保持原有的状态，而基类的私有成员仍然是私有的，不能被派生类访问。
私有继承的特点：基类的公有成员和保护成员都为派生类的私有成员，而不能被派生类的子类访问，但是可以被派生类的成员函数访问；
保护继承的特点：基类的公有成员和保护成员都为派生类的保护成员，而且只能被派生类的成员函数访问或者友元访问，基类的私有仍然是私有
#include <iostream>

using namespace std;
class basescore{
int math;
protected:
int eng;
public:
int chem;

};
class dbase1:public basescore{//公有继承
public:
void input(){
cout<<"输入英语成绩： ";
cin>>eng; //直接用基类的保护成员
cout<<"输入c++成绩： ";
cin>>chem; //引用基类的公有成员
}
void output(){
cout<<"英语成绩： "<<eng<<endl;
cout<<"c++成绩： "<<chem<<endl;
}
};

class dbase2:private basescore{ //私有继承

public:
void input(){
cout<<"输入英语成绩： ";
cin>>eng;
cout<<"输入c++成绩： ";
cin>>chem;
}
void output(){
cout<<"英语成绩： "<<eng<<endl;
cout<<"c++成绩： "<<chem<<endl;
}

};

int main(int argc, char** argv) {

dbase1 pub;
pub.input();
dbase2 pri;
pri.input();
int s=pub.chem; //读取公有继承c++成绩
cout<<s<<endl;
pub.output();
pri.output();
return 0;
}

基类就是一个普通的类，任何一个类若被其他类继承，这个类就是基类，派生类就是继承基类的类，派生类既包含基类的所有信息，又有自己独特的内容。

c++自学笔记3

标签：

原文地址：http://blog.csdn.net/lotluck/article/details/43153691

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行