c++ class基础知识
class
定义, 类一般定义在函数外面(也可以定义在函数内部, 但比较少见).
class Student{
public:
char *name;
int age;
float score;
void say(){
cout << "name=" << name << ", age=" << age << ", score=" << score << endl;
}
};
注意, 需要有分号表示类定义结束, 因为大括号和分号中间还可以添加对象列表:
class Student{
语句;
} stu1, stu2;
创建对象
class Student LiLei; //创建单个对象
Student LiLei; // 最开始可以不要class关键字
Student AllStu[100]; //创建一个对象数组
通过对象名称访问类成员
stu1.name = "小明";
stu1.say();
对象指针
Student stu1;
Student *pStu1 = &stu1; // pStu1是指针, 指向stu1的地址
Student *pStu2 = new Student; //使用new创建的对象没有名字, 只能得到一个指针, 所以需要使用指针变量来接收.
栈内存: 由程序自动管理, 不能使用delete删除在栈上创建的对象;
堆内存: 由程序员管理, 对象使用完后可以通过delete删除.
通过new创建的对象在堆上分配内存, 后续要通过delete删除, 防止无用内存堆积.
通过对象指针访问类成员
Student *pStu1 = &stu1;
pStu1 -> name = "小明";
pStu1 -> say();
类方法可以定义在类体外部(要用到域解析符:😃.
类方法定义在类内部会自动成为内联函数, 一般情况下这样不好, 所以类方法一般都定义在类体外部.
class Student{
public:
char *name;
int age;
float score;
void say(); //类定义中声明函数
};
void Student::say(){ //类之外定义函数, 需要使用Student::say()
cout << "name=" << name << ", age=" << age << ", score=" << score << endl;
}
类成员/类方法访问权限
类成员/类方法有三种访问权限: public, protected, private. 默认是private.
public: 可访问范围: 类内部, 类外部, 派生类内部.
private: 可访问范围: 类内部
protected:可访问范围: 类内部, 派生类内部
一般做法:
- 将所有变量声明为private, 外部要访问时只能通过set函数和get函数.
- 将外部需要使用的函数声明为public, 其余都声明为private.
构造函数
#include <iostream>
using namespace std;
class Student{
private:
char *m_name;
int m_age;
float m_score;
public:
Student(char *name, int age, float score);
void show();
};
Student::Student(char *name, int age, float score){ //构造函数不需要返回类型
m_name = name;
m_age = age;
m_score = score;
}
int main(){
Student stu1("XiaoMing", 15, 59.5); //实参写在对象后面
Student *p_stu2 = new Student("XiaoHong", 17, 99.5); //实参写在类名后面
}
构造函数需要是public的.
构造函数允许重载.
构造函数可以使用初始化列表形式对成员变量赋值:
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){
//TODO;
}
初始化列表赋值顺序要与在类中声明顺序一致.
#include <iostream>
using namespace std;
class Demo{
private:
int m_a;
int m_b;
public:
Demo(int b);
void show();
};
Demo::Demo(int b) : m_b(b), m_a(m_b){
//相当于
//m_a = m_b; // 类体中, m_a先声明, 所以先调用给m_a的赋值, 导致将m_b的值给m_a
//m_b = b;
}
void Demo::show(){
cout << "m_a=" << m_a << ", m_b=" << m_b << endl;
}
int main(){
Demo d0(1);
d0.show(); // m_a=4201051, m_b=1 //m_a得到一个未初始化的值.
}
const成员变量只能在初始化列表中初始化.
析构函数Destructor
在销毁对象时自动执行.
程序员无法调用.
名称是在类名前加~.
没有返回值, 没有参数, 不能重载.
this指针
this 是c++中的关键字, 也是一个const指针, 指向当前对象, 用它可以访问当前对象的所有成员.
当成员函数的参数与成员变量重名时, 就可以用this来区分它们: this->name = name;
this是一个指针, 所以访问成员时要使用->.
静态变量
在多个成员间共享数据.
定义方法:
public:
static int m_total;
初始化方法, static成员只能在类声明的外部初始化:
//初始化格式
//变量类型 类名::变量名 = 变量值;
int Student::m_total = 0;
static成员变量访问方式:
//通过类来访问:
int a = Student::m_total;
//通过对象来访问:
stu.m_total = 20;
//通过对象指针来访问:
pstu->m_total = 20;
static成员变量不占用对象的内存, 而是在对象之外开辟内存.
静态函数
普通函数可以访问所有变量和函数
静态函数只能访问静态变量和静态函数.
静态函数中没有形参this.
静态函数在声明时要加上static, 定义时不能加static.
静态函数可以通过类来调用, 也可以通过对象调用.
const变量与const函数
const成员变量的用法和普通const变量的用法相似, 只能通过构造函数初始化列表进行初始化.
const成员函数可以使用类中所有变量, 但不能修改它们的值, 比如get函数.
const成员函数在声明和定义时都要加const关键字:
//声明
public:
char *getname() const;
int getage() const;
float getscore() const;
//定义
char * Student::getname() const {
return m_name;
}
int Student::getage() const {
return m_age;
}
float Student::getscore() const {
return m_score;
}
//注意: const位置不同代表不同的含义
// const char *getname(); //表示返回值是const.
// char *getname() const; //表示函数是const, 即函数中不能修改类成员.
const对象
const也可以用来修饰对象, 称为常对象, 这时只能调用const成员.
//常对象
const 类名 对象名(参数);
类名 const 对象名(参数);
//常对象
const 类名 *对象指针名(参数);
类名 const *对象指针名(参数);
友元函数, 友元类, friend
友元函数: 将一个函数声明为一个类的friend.
#include <iostream>
using namespace std;
class Address; //声明Addrss类
class Student{
public:
string name;
int age;
Student(string name, int age);
void show(Address *addr); //在Student中声明show函数
};
class Address{
private:
string province;
string city;
public:
Address(string prov, string city);
//在Address中, 将Student里的show定义为friend, 这样Student::show就可以访问Address类的private变量了.
friend void Student::show(Address *addr);
};
Student::Student(string name, int age){
this->name = name;
this->age = age;
}
void Student::show(Address *addr){ //正常定义show函数.
cout << "name=" << name << ", age=" << age << ", prov=" << addr->province << ", city=" << addr->city << endl;
}
Address::Address(string prov, string city){
this->province = prov;
this->city = city;
}
int main(){
Address addr0("SiChuan", "Chengdu");
Student stu0("XiaoMing", 15);
stu0.show(&addr0);
Address *p_addr1 = new Address("HeBei", "ShiJiaZhuang");
Student *p_stu1 = new Student("XiaoHong", 17);
p_stu1->show(p_addr1);
}
友元类: 将一个类声明为另一个类的friend.
#include <iostream>
using namespace std;
class Address; //声明Addrss类
class Student{
public:
Student(string name, int age);
void show(Address *addr);
private:
string name;
int age;
};
class Address{
private:
string province;
string city;
public:
Address(string prov, string city);
//在Address中, 将Student定义为friend, 这样Student就可以访问Address类的private变量了.
//注意,
// Address认为Student是friend, 允许Student访问Address的private,
// 但Student不认为Address是friend, 所以不让Address访问Student的private.
friend class Student;
};
Student::Student(string name, int age){
this->name = name;
this->age = age;
}
void Student::show(Address *addr){ //正常定义show函数.
cout << "name=" << name << ", age=" << age << ", prov=" << addr->province << ", city=" << addr->city << endl;
}
Address::Address(string prov, string city){
this->province = prov;
this->city = city;
}
int main(){
Address addr0("SiChuan", "Chengdu");
Student stu0("XiaoMing", 15);
stu0.show(&addr0);
Address *p_addr1 = new Address("HeBei", "ShiJiaZhuang");
Student *p_stu1 = new Student("XiaoHong", 17);
p_stu1->show(p_addr1);
}
class和struct区别
- struct只能包含变量, 不能包含函数. class可以包含变量和函数.
- struct成员默认都是public, class成员默认都是private.
- struct继承默认是public继承, class继承默认是private继承.
- struct不能使用模板, class可以使用模板.
