对老师上课ppt的归纳与整理,以便加深记忆
注意:分号不能少
class Test{
int x=5,y=6;//不合法
extern float x;//不允许
};
class student{
}stu1,stu2;
class {
}stu1,stu2;
函数定义:通常在类定义中,成员函数仅作声明。 函数定义通常在类的声明之后,在类外进行。
返回值类型 类名::函数名(参数表)
{
···//函数体
}
其中运算符“::”称为作用域运算符,它指出该函数是属于哪一个类的成员函数。
类的成员具有类作用域。 它们不是全局函数。
在类内定义的函数默认为内联函数 ,在类内用inline声明的函数,在类外定义前面加inline。内联成员函数只能在定义它们的文件中调用。
class student{
int n;
public:
void display1();
inline void display2();
};
void student::display1()
{
cout<<"hi"<<endl;
}
inline void student::display2()
{
cout<<"n:"<<n<<endl;
}
stu1.display();
student *p,stu1;
p=&stu1;
p ->display();
(*p) . display();
student stu1;
student &pp=stu1;
pp.display();
构造函数是一种特殊的成员函数,它主要用于对对象成员进行初始化。(给具体数值,或给指针成员分配空间等)
在创建对象时,系统会自动地调用构造函数。 从而保证了先初始化后访问的顺序。
#include<iostream>
#include<cmath>
using namespace std;
class complex{
private:
double real,imag;
public:
//无参构造函数
complex()
{
real=6;imag=8;
}
//有参构造函数
complex(double r,double i)//形参不要与数据成员同名
{
real=r;imag=i;
}
double abscomplex()
{
double t;
t=real*real+imag*imag;
return sqrt(t);
}
};
int main()
{
complex A(1.1,2.2);//定义类的对象A时调用构造函数complex
complex B;
cout<<"abs of complex A="<<A.abscomplex()<<endl;
cout<<"abs of complex B="<<B.abscomplex()<<endl;
return 0;
}
class complex{
private:
double real,imag;
public:
//无参构造函数
complex()
{
real=6;imag=8;//初始化成员变量
}
};
调用形式:complex A;
class complex{
private:
double real,imag;
public:
//有参构造函数
complex(double r,double i)//形参不要与数据成员同名
{
real=r;imag=i;
}
};
隐式调用构造函数: complex A(1.1 , 2.2);
显式调用构造函数: complex A=complex(1.1 , 2.2);
class complex{
private:
double real,imag;
public:
//初始化列表
complex(double r,double i):real(r),imag(i)
{}
};
#include<iostream>
#include<cmath>
using namespace std;
class complex{
private:
double real,imag;
public:
//使用默认参数的构造函数
complex(double r=1,double i=1);
double abscomplex()
{
double t;
t=real*real+imag*imag;
return sqrt(t);
}
};
complex::complex(double r,double i)
{
real=r;imag=i;
}
int main()
{
complex A(1.1,2.2);//定义类的对象A时调用构造函数complex
complex B;
complex C(2);
cout<<"abs of complex A="<<A.abscomplex()<<endl;
cout<<"abs of complex B="<<B.abscomplex()<<endl;
cout<<"abs of complex C="<<C.abscomplex()<<endl;
return 0;
}
complex::complex( ){ ;} //是一个无参空函数。
析构函数也是一种特殊的成员函数。它执行与构造函数相反的操作,通常用于执行一些清理任务,如释放分配给对象的内存空间等,并不是删除对象
#include<iostream>
#include<cmath>
using namespace std;
class complex{
double real,imag;
public:
complex(double r=0.0,double i=0.0)
{
cout<<"construction..."<<endl;
real=r;imag=i;
}
~complex()
{
cout<<"destruction..."<<endl;
}
double abscomplex()
{
return sqrt(real*real+imag*imag);
}
};
int main()
{
complex a(1.1,2.2);
cout<<"abs of complex a="<<a.abscomplex()<<endl;
return 0;
}
若没有显式地为一个类定义析构函数,编译系统会自动地添加一个缺省的析构函数。
~complex(){}
对于大多数类而言,缺省的析构函数已经足够了。但是,如果在一个对象完成其操作之前需要做一些内部处理,则应该显式地定义析构函数
先构造的后析构,后构造的先析构
在主函数之前构造,主函数结束或调用exit(0)时析构。
函数调用,建立对象时构造,函数结束时析构。 多次调用函数,就多次构造和析构。
程序第一次调用函数时构造,主函数结束或调用exit(0)析构。其间,调用函数不构造也不析构。
若一个类有若干个对象,我们把这一系列的对象用一个数组来存放。建立对象数组时,每一个元素都要调用构造函数初始化。
#include<iostream>
#include<cmath>
using namespace std;
class complex{
double real,imag;
public:
complex(double a)
{
real=a;imag=a;
cout<<"1"<<endl;
}
complex(double r,double i)
{
real=r;imag=i;
cout<<"2"<<endl;
}
complex()
{
real=imag=0.0;
cout<<"3"<<endl;
}
double abscomplex()
{
double t;
t=real*real+imag*imag;
return sqrt(t);
}
};
int main()
{
complex demo1[5];
cout<<"demo1[0]: "<<demo1[0].abscomplex()<<endl;
cout<<"————"<<endl;
complex demo2[5]={complex(1),complex(),complex(1.1,2.2)} ;
cout<<"demo2[0]: "<<demo2[0].abscomplex()<<endl;
cout<<"————"<<endl;
complex demo3[5]={1,4,2,3,6};
cout<<"demo3[0]: "<<demo3[0].abscomplex()<<endl;
cout<<"————"<<endl;
}
这个类必须有无参构造函数或形参皆有缺省值
#include<iostream>
#include<cmath>
using namespace std;
class complex{
double real,imag;
public:
complex(double a)
{
real=a;imag=a;
cout<<"1"<<endl;
}
complex(double r,double i)
{
real=r;imag=i;
cout<<"2"<<endl;
}
complex()
{
real=imag=0.0;
cout<<"3"<<endl;
}
double abscomplex()
{
double t;
t=real*real+imag*imag;
return sqrt(t);
}
};
int main()
{
complex *p=new complex[3];
cout<<"————"<<endl;
p[0]=complex(1.0,2.0);
cout<<"p[0]:"<<p[0].abscomplex()<<endl;
cout<<"————"<<endl;
p[1]=complex(3.0);
cout<<"p[1]:"<<p[1].abscomplex()<<endl;
cout<<"————"<<endl;
p[2]=complex();
cout<<"p[2]:"<<p[2].abscomplex()<<endl;
cout<<"————"<<endl;
delete []p;
return 0;
}
对象空间的起始地址,称为对象的指针
#include<iostream>
using namespace std;
class time{
public:
int h,m,s;
void get_time();
};
void time::get_time()
{
cout<<h<<":"<<m<<":"<<s<<endl;
}
int main()
{
time *p;//p为指向time类的对象的指针变量
time t;//t为time类对象
p=&t;//p为指向time类对象t的指针变量
(*p).h=1;(*p).m=10;(*p).s=50;
(*p).get_time();
return 0;
}
double *p1=&a.m; *p1=6;
class ABC{
int x;
public:
void set(int x)
{
this->x=x;//或(*this).x=x;
}
};
类名 const 对象名 [(实参表列)];
const 类名 对象名 [(实参表列)];
用const来声明常数据成员,其值不能改变,不能被赋值。只能通过构造函数的参数初始化表对常数据成员进行初始化。
class time{
const int h;
int s;
public:
time(int hour):h(hour)//只能通过构造函数的参数初始化表对常数据成员进行初始化。
{
s=0;
}
};
返回类型 成员函数名(形参)const
类名 * const 指针变量名 =对象地址;
指针值始终保持为其初始化值,不能改变,即其指向始终不变。
time t1(10,12,15);
time *const p=&t1;
不能通过该指针改变其所指变量的值。
该指针可以指向不同的变量。
int a;
const int b=7;
const int *p;
p=&a;
*p=9;//错误,不能通过该指针改变其所指变量的值。
p=&b;
void fun(const Time &t);
// 则在函数fun中不能改变t的值,也就是不能改变其对应的实参的值
利用new运算符动态建立对象,用delete运算符撤销对象
在执行delete运算符时,在释放内存空间之前,自动调用析构函数
将对象名2的值赋给对象名1: 对象名1=对象名2
用一个已有的对象快速地复制出多个完全相同的对象:①类名 对象名2(对象名1) ②类名 对象名1=对象名2;
在类定义中,它的成员(包括数据成员和成员函 数)可以用关键字static声明为静态的
不管这个类创建了多少个对象,静态成员只有一个拷贝, 这个拷贝被所有属于这个类的对象共享。
与一般的数据成员不同,无论建立了多少个对象,在内存中都只有一个静态数据的拷贝。静态数据成员是单独存储的,而不是对象的组成部分。
必须在类声明之外使用单独的语句初始化。一般在main() 开始之前、类的声明之后的全局地带为它初始化。不能在类中进行初始化,也不能通过构造函数初始化。因为在类中不给它分配内存空间。缺省时,静态成员被初始为0。
数据类型 类名::静态数据成员名=初值;
静态数据成员与静态变量一样,是在编译时创建并初始化。它在该类的任何对象被建立之前就存在,它可以在程序内部不依赖于任何对象被访问 。到程序结束时才释放。
静态数据成员属于类,而不像普通数据成员那样属于某一对象,因此可以使用
“类名::” 访问公有的静态数据成员
也可通过对象名引用。
对私有静态数据成员只能通过类成员函数访问。
静态数据成员的主要用途是 定义类的各个对象所公用的数据,如统计总数、平均数等, 而可以不必使用全局变量。依赖于全局变量的类几乎都 是违反面向对象程序设计的封装原理的。
使得类外部的函数或类能够访问类中的私有成员
友元既可以是不属于任何类的一般函数,也可以是另一个类的成员函数,还可以是整个一个类(这样,这个类中的所有成员函数都可以成为友元函数)。
友元函数不是当前类的成员函数,而是独立于当前类的外部函数,但它可以访问该类的所有对象的成员,包括私有成员和公有成员。
在类定义中声明友元函数时,需在其函数名前加上关键字friend。
此声明可以放在公有部分,也可以放在私有部分。
友元函数可以定义在类的内部,也可以定义在类的外部。
#include<iostream>
#include<string>
using namespace std;
class girl{
private:
string name;
int age;
public:
girl(string n,int a)
{
name=n;age=a;
}
friend void disp(girl &);//声明友元函数
};
void disp(girl &x)//定义友元函数
{
cout<<x.name<<endl<<x.age<<endl;
}
int main()
{
girl g("Alice",18);
disp(g);//调用友元函数
return 0;
}
一个类的成员函数也可以作为另一个类的友元,这种成员函数不仅可以访问自己所在类对象中的私有成员和公有成员, 还可以访问friend声明语句所在类对象中的私有成员和公有成员,这样能使两个类相互合作、协调工作,完成某一任务。
定义了函数模板之后,可以产生针对不同数据类型使用相同功能的函数实例。
template < class T >
或 template < typename T >
#include<iostream>
#include<string>
using namespace std;
template<class T>
T maxn(T a,T b)
{
return (a>b)?a:b;
}
int main()
{
cout<<maxn(10,20)<<endl;
cout<<maxn(10.5,20.5);
return 0;
}
按标识符取名。如有多个类型参数,每个类型参数都要以class为前导,两个类型参数之间用逗号分隔。
#include<iostream>
using namespace std;
template<class numtype>
class compare{
private:
numtype x,y;
public:
compare(numtype a,numtype b)
{
x=a;y=b;
}
numtype maxnum()
{
return (x>y)?x:y;
}
numtype minnum()
{
return (x<y)?x:y;
}
};
template<class numtype>
numtype compare<numtype>::max()
{ return (x>y)?x:y;}
#include<iostream>
using namespace std;
template<class numtype>
class compare{
private:
numtype x,y;
public:
compare(numtype a,numtype b)
{
x=a;y=b;
}
numtype maxnum()
{
return (x>y)?x:y;
}
numtype minnum()
{
return (x<y)?x:y;
}
};
int main()
{
compare<int> cmp1(3,7);
cout<<"max:"<<cmp1.maxnum()<<endl;
cout<<"min:"<<cmp1.minnum()<<endl;
compare<float>cmp2(45.78,93.6);
cout<<"max:"<<cmp2.maxnum()<<endl;
cout<<"min:"<<cmp2.minnum()<<endl;
compare<char>cmp3(‘a‘,‘A‘);
cout<<"max:"<<cmp3.maxnum()<<endl;
cout<<"min:"<<cmp3.minnum()<<endl;
return 0;
}
原文:https://www.cnblogs.com/jasf/p/12890080.html