1.this指针
当前的对象,在类的内部访问成员使用,pubic,protected,private;
只能在非静态成员函数内部使用;
2. static 在C++中
static在类的内部修饰变量,对象是共享使用,在类内声明,在类外定义;
类型 类名::变量名 = 数值;
在类内声明的时候前面加static,在类外初始化的时候不需要加static
类外不初始化static变量不能使用
三种访问形式:
1.通过类名:int Student::m_total = 0;
2. 通过对象:
Student stu("小明", 15, 92.5f);
stu.m_total = 20;
3.通过堆上对象指针来访问:
Student *pstu = new Student("xiaoming", 16, 89);
pstu->m_total = 30;
3. static 静态成员函数
没有this指针,只能访问静态成员;
4. const
cost成员函数可以访问类内的所有元素,但是不能修改,const函数称为常成员函数;
void setage(int age)与void setage(int age) const 是两个不同的函数
const对象:常对象,只能访问类的const成员
5. 友元函数与友元类
友元可以访问当前类的所有成员:public,protected,private;
友员函数不能直接访问类的内部成员,必须要借助对象
void show(Student *pstu)
{
cout<< pstu->m_name<<","<<pstu->m_age<<","<<pstu->m_score<<endl;
}
类内声明,类外定义;
关键字friend
1)独立函数声明为友员函数
2)其他类的成员函数声明为友员函数
友员的单向关系,不能传递:
B是A的友员,C是B的友员,C是A的友员? 这个是不成立的
3)友元类
类A是类B的友员,那么A的所有函数都是B的友员
友员类是单向的,不是双向的;
6.string
string s1; 只定义不初始化,编译器自动给空;
string s2=“suqian”;定义的时候初始化; 只有六个元素,不包含\0,如果在c中是7个
string s3 = s2; s2的内容赋值给s3;
string s4 (5, 's'); 在s4中填5个s;
7. length
求字符串的长度
string s = "suqian";
int lenth = s.length();
8.cin 字符串的输入输出;
string s1;
cin>>s1;
nanjing jiangning
cout<<s1<<endl;
输出只有nanjing,cin遇到空格自动结束;s1只有nanjing;
9.string可以访问下标
10.string字符串的拼接;+,+=;
string s1 = "abcd";
string s2 = "123";
string s3;
s3 =s1+s2;
cout<<s3<<endl;
输出:abcd123
10.string插入;
它的一种原型为:
string& insert (size_t pos, const string& str);
pos:要插入的位置;
str:要插入的字符串;
string s1,s2,s3;
s1 = "1234567890";
s2 = "abcdefgh";
s3 = "abc";
s1.insert(5, s3); 第5个位置,插入abc
cout<<s1<<endl;
s2.insert(3,"123"); 第3个位置,插入123
cout<<s2<<endl;
11.删除erase()
原型为:string& erase (size_t pos = 0, size_t len = npos);
pos:起始的下标,
len:删除的长度;
如果len不确定的话,把pos后面的全部删除;
12.提取:substr()
原型为:
string substr (size_t pos = 0, size_t len = npos) const;
pos:提取的下标, len是长度;
13.字符串的查找find
查找出现的位置:
它其中的两种原型为:
size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* str, size_t pos = 0) const;
str:查找的字符串,
pos:开始的下标
出现问题正常:没找到
string s1 = "one two three four";
string s2 = "fince";
int index = s1.find(s2, 0);
int len = s1.length();
if(index < s1.length())
cout<<"Found at index : "<< index <<endl;
else
cout<<"Not found"<<endl;
出现问题:index = -1;
string s1 = "one two three four";
string s2 = "fince";
int index = s1.find(s2, 0);
int len = s1.length();
if(index < len)
cout<<"Found at index : "<< index <<endl;
else
cout<<"Not found"<<endl;
13.继承
一个类从另外类中获取变量和函数,称为继承;
父类,基类;
子类,派生类;
继承的一般语法:
class 派生类名:继承方式 基类名{
派生类的成员;
};
继承的方式:public,protect,private,不写的话默认private
1.基类中的public可以在派生类中使用;
基类中的protected也可以在派生类中使用;
基类中private成员不能在派生类中使用;
public>protected>private
2.public形式继承的:
基类中的public成员还是public:
........protected成员还是protected;
........private成员不能在派生类中使用;
3.protected继承:
基类中public成员在派生类中为protected属性;
......protected............protected.....;
......private在派生类中不能使用;
4.private继承;
基类中的public成员在派生类中为private属性;
........protected............private.....;
........private成员在派生类中还是不能使用;
访问基类中的private成员必须借助基类中public属性的函数;
否则在派生类中无法访问;
基类创建的对象:只能访问基类的public成员变量,不能访问protected,private属性的变量;
在派生类创建的对象,也不能访问基类的protected,private变量成员,只能public;
基类中的protected属性成员,1.只能在派生类的内部函数访问,2.基类中的函数也可以访问;
5. using改变访问权限
Using不能修改基类的private成员,在派生类中无法访问基类的private;
可以把public改成派生类中的private,也可以将基类中protected改成public,或者是private;
6.继承时的名字遮拦
派生类的成员和基类中的成员重名,那么就会遮拦从基类继承过来的成员;
派生类在使用该成员时,实际上是派生类新增的成员,不是从基类中继承来的
在基类和派生类中,不管是成员变量,还是成员函数,只要名字一样就会造成遮蔽;
7.派生类的构造函数
构造函数不能被继承,
派生类的构造函数可以调用基类的构造函数类实现;
Student::Student(char *name, int age,float score):People(name,age), m_score(score){}
1.20
1.名字的遮蔽
基类的成员函数和派生类的成员函数不构成重载;
基类成员和派生类成员的名字一样会造成遮蔽;
2.派生类的构造函数
构造函数不能被继承;
在派生类的构造函数中可以调用基类的构造函数来实现
3.构造函数的调用顺序
基类A,派生出B,B再派生出C;
他们的构造函数调用顺序:
A --> B--->C
派生类构造函数中只能调用直接基类的构造函数,不能调用间接基类的构造函数;
4.析构函数
基类的析构函数不能被继承;
基类和派生类:A,B,C
构造的时候顺序:A,B,C
析构的顺序:C, B, A
5. 多继承类
class C:public A, public B, public D{
};
多继承下的构造函数,和单继承一样,都是调用基类的构造函数;
6. 命名冲突
当多继承的时候,如果c分别从A和B继承函数,如果是函数名有相同,编译器会报错,这个时候要加上::来进行说明;
7.虚继承虚基类;
表示共享它的基类:virtual
8.虚继承的时候,多继承的状态下,间接的基类最终由最终的派生类来确定初始化的值;
最终的派生类D来初始化虚基类A,直接派生类B和C对A的构造函数的调用是无效的;
//直接基类B
class B: virtual public A{ //虚继承
protected:
int m_b;
};
//直接基类C
class C: virtual public A{ //虚继承
protected:
int m_c;
};
8.引用
相当于一个别名;
语法格式:type &name = data;
int xiaoW;
int &xiaoG = xiaoW;
1) &不是地址预算法,是一个引用运算符
2)xiaoG,xiaoW变量的地址和值都是一样;
3) 引用只能初始化,不能先声明后赋值;相当于一个常量;
4)。在声明一个引用的时候必须初始化;
5).这个别名别人不能用,只能这个变量使用;改变变量的值,这个别名的值也会改变;
开始定义初始化的时候&表示引用运算符;
引用初始化后,&表示区地址运算符;
可以对对象和变量进行引用;
但是不能对类进行引用,因为类没有内存地址;
当前的对象,在类的内部访问成员使用,pubic,protected,private;
只能在非静态成员函数内部使用;
2. static 在C++中
static在类的内部修饰变量,对象是共享使用,在类内声明,在类外定义;
类型 类名::变量名 = 数值;
在类内声明的时候前面加static,在类外初始化的时候不需要加static
类外不初始化static变量不能使用
三种访问形式:
1.通过类名:int Student::m_total = 0;
2. 通过对象:
Student stu("小明", 15, 92.5f);
stu.m_total = 20;
3.通过堆上对象指针来访问:
Student *pstu = new Student("xiaoming", 16, 89);
pstu->m_total = 30;
3. static 静态成员函数
没有this指针,只能访问静态成员;
4. const
cost成员函数可以访问类内的所有元素,但是不能修改,const函数称为常成员函数;
void setage(int age)与void setage(int age) const 是两个不同的函数
const对象:常对象,只能访问类的const成员
5. 友元函数与友元类
友元可以访问当前类的所有成员:public,protected,private;
友员函数不能直接访问类的内部成员,必须要借助对象
void show(Student *pstu)
{
cout<< pstu->m_name<<","<<pstu->m_age<<","<<pstu->m_score<<endl;
}
类内声明,类外定义;
关键字friend
1)独立函数声明为友员函数
2)其他类的成员函数声明为友员函数
友员的单向关系,不能传递:
B是A的友员,C是B的友员,C是A的友员? 这个是不成立的
3)友元类
类A是类B的友员,那么A的所有函数都是B的友员
友员类是单向的,不是双向的;
6.string
string s1; 只定义不初始化,编译器自动给空;
string s2=“suqian”;定义的时候初始化; 只有六个元素,不包含\0,如果在c中是7个
string s3 = s2; s2的内容赋值给s3;
string s4 (5, 's'); 在s4中填5个s;
7. length
求字符串的长度
string s = "suqian";
int lenth = s.length();
8.cin 字符串的输入输出;
string s1;
cin>>s1;
nanjing jiangning
cout<<s1<<endl;
输出只有nanjing,cin遇到空格自动结束;s1只有nanjing;
9.string可以访问下标
10.string字符串的拼接;+,+=;
string s1 = "abcd";
string s2 = "123";
string s3;
s3 =s1+s2;
cout<<s3<<endl;
输出:abcd123
10.string插入;
它的一种原型为:
string& insert (size_t pos, const string& str);
pos:要插入的位置;
str:要插入的字符串;
string s1,s2,s3;
s1 = "1234567890";
s2 = "abcdefgh";
s3 = "abc";
s1.insert(5, s3); 第5个位置,插入abc
cout<<s1<<endl;
s2.insert(3,"123"); 第3个位置,插入123
cout<<s2<<endl;
11.删除erase()
原型为:string& erase (size_t pos = 0, size_t len = npos);
pos:起始的下标,
len:删除的长度;
如果len不确定的话,把pos后面的全部删除;
12.提取:substr()
原型为:
string substr (size_t pos = 0, size_t len = npos) const;
pos:提取的下标, len是长度;
13.字符串的查找find
查找出现的位置:
它其中的两种原型为:
size_t find (const string& str, size_t pos = 0) const;
size_t find (const char* str, size_t pos = 0) const;
str:查找的字符串,
pos:开始的下标
出现问题正常:没找到
string s1 = "one two three four";
string s2 = "fince";
int index = s1.find(s2, 0);
int len = s1.length();
if(index < s1.length())
cout<<"Found at index : "<< index <<endl;
else
cout<<"Not found"<<endl;
出现问题:index = -1;
string s1 = "one two three four";
string s2 = "fince";
int index = s1.find(s2, 0);
int len = s1.length();
if(index < len)
cout<<"Found at index : "<< index <<endl;
else
cout<<"Not found"<<endl;
13.继承
一个类从另外类中获取变量和函数,称为继承;
父类,基类;
子类,派生类;
继承的一般语法:
class 派生类名:继承方式 基类名{
派生类的成员;
};
继承的方式:public,protect,private,不写的话默认private
1.基类中的public可以在派生类中使用;
基类中的protected也可以在派生类中使用;
基类中private成员不能在派生类中使用;
public>protected>private
2.public形式继承的:
基类中的public成员还是public:
........protected成员还是protected;
........private成员不能在派生类中使用;
3.protected继承:
基类中public成员在派生类中为protected属性;
......protected............protected.....;
......private在派生类中不能使用;
4.private继承;
基类中的public成员在派生类中为private属性;
........protected............private.....;
........private成员在派生类中还是不能使用;
访问基类中的private成员必须借助基类中public属性的函数;
否则在派生类中无法访问;
基类创建的对象:只能访问基类的public成员变量,不能访问protected,private属性的变量;
在派生类创建的对象,也不能访问基类的protected,private变量成员,只能public;
基类中的protected属性成员,1.只能在派生类的内部函数访问,2.基类中的函数也可以访问;
5. using改变访问权限
Using不能修改基类的private成员,在派生类中无法访问基类的private;
可以把public改成派生类中的private,也可以将基类中protected改成public,或者是private;
6.继承时的名字遮拦
派生类的成员和基类中的成员重名,那么就会遮拦从基类继承过来的成员;
派生类在使用该成员时,实际上是派生类新增的成员,不是从基类中继承来的
在基类和派生类中,不管是成员变量,还是成员函数,只要名字一样就会造成遮蔽;
7.派生类的构造函数
构造函数不能被继承,
派生类的构造函数可以调用基类的构造函数类实现;
Student::Student(char *name, int age,float score):People(name,age), m_score(score){}
1.20
1.名字的遮蔽
基类的成员函数和派生类的成员函数不构成重载;
基类成员和派生类成员的名字一样会造成遮蔽;
2.派生类的构造函数
构造函数不能被继承;
在派生类的构造函数中可以调用基类的构造函数来实现
3.构造函数的调用顺序
基类A,派生出B,B再派生出C;
他们的构造函数调用顺序:
A --> B--->C
派生类构造函数中只能调用直接基类的构造函数,不能调用间接基类的构造函数;
4.析构函数
基类的析构函数不能被继承;
基类和派生类:A,B,C
构造的时候顺序:A,B,C
析构的顺序:C, B, A
5. 多继承类
class C:public A, public B, public D{
};
多继承下的构造函数,和单继承一样,都是调用基类的构造函数;
6. 命名冲突
当多继承的时候,如果c分别从A和B继承函数,如果是函数名有相同,编译器会报错,这个时候要加上::来进行说明;
7.虚继承虚基类;
表示共享它的基类:virtual
8.虚继承的时候,多继承的状态下,间接的基类最终由最终的派生类来确定初始化的值;
最终的派生类D来初始化虚基类A,直接派生类B和C对A的构造函数的调用是无效的;
//直接基类B
class B: virtual public A{ //虚继承
protected:
int m_b;
};
//直接基类C
class C: virtual public A{ //虚继承
protected:
int m_c;
};
8.引用
相当于一个别名;
语法格式:type &name = data;
int xiaoW;
int &xiaoG = xiaoW;
1) &不是地址预算法,是一个引用运算符
2)xiaoG,xiaoW变量的地址和值都是一样;
3) 引用只能初始化,不能先声明后赋值;相当于一个常量;
4)。在声明一个引用的时候必须初始化;
5).这个别名别人不能用,只能这个变量使用;改变变量的值,这个别名的值也会改变;
开始定义初始化的时候&表示引用运算符;
引用初始化后,&表示区地址运算符;
可以对对象和变量进行引用;
但是不能对类进行引用,因为类没有内存地址;