c++ class基础知识

目录

• class
• 创建对象
• 通过对象指针访问类成员
• 类方法可以定义在类体外部(要用到域解析符:.
• 类成员/类方法访问权限
• 构造函数
• 析构函数Destructor
• this指针
• 静态变量
• 静态函数
• const变量与const函数
• const对象
• 友元函数, 友元类, friend
• class和struct区别

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:可访问范围: 类内部, 派生类内部

一般做法:

1. 将所有变量声明为private, 外部要访问时只能通过set函数和get函数.
2. 将外部需要使用的函数声明为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区别

1. struct只能包含变量, 不能包含函数. class可以包含变量和函数.
2. struct成员默认都是public, class成员默认都是private.
3. struct继承默认是public继承, class继承默认是private继承.
4. struct不能使用模板, class可以使用模板.