首页 > 代码库 > c++自学笔记3

c++自学笔记3

2024-11-17 14:42:39   204人阅读

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


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


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


联系
我们