c++之类和对象

the second day

学习目录：

一,类和对象

1.定义

2.创建对象方式

3.访问类的成员

4.访问权限

5.类的封装

二,构造函数

三,初始化列表

四,this指针

五,析构函数

六,关键字：static,const

七,友元函数

学习总结：

一.类和对象：

1.类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例（Instance），拥有类的成员变量和成员函数，类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。例如：

#include <iostream>

using namespace std;

class A                                               //通过class关键字创建一个类A，类名称首字母通常大写

{

private:

int m_a,m_b;     //m_a,m_b是类的成员变量

public:

void show()                        //类的成员函数

{                                           //注意：在类中不能对成员变量赋值，它只是一个类模板，不占用空间

cout<<"a"<<endl;

}

}

int main()

{

A a;                                                    //创建对象a;

}

2.创建对象：class A a;

                         A a;

                         A   *b=new A;              //这三种方式都可以

3.访问类的成员：可以用对象名.成员变量/成员函数，也可以用指针，比如：

                                 a.m_a;             a.show();

                                  b->m_a;          b->show();

4.访问权限：在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制，但的是如果是类以外的函数是不能访问private属性的成员的。例如：

Student stu;
//m_name、m_age、m_score 是私有成员变量，不能在类外部通过对象访问
stu.m_name = "小明";
stu.m_age = 15;
stu.m_score = 92.5f;
stu.show();

5.类的封装：所谓封装，是指尽量隐藏类的内部实现，只向用户提供有用的成员函数，我们可以将成员变量声明为private属性，额外添加两个 public 属性的成员函数，一个用来设置成员变量的值，一个用来修改成员变量的值，这种将成员变量声明为 private、将部分成员函数声明为 public 的做法体现了类的封装性。

 二.构造函数

特点：1.名称与类名相同，没有返回值，无需用户显示调用，在创建对象时自动执行。

2.如果没有在类中提供构造函数，系统会自动生成一个既无参数也无函数体的空构造函数。。

3.构造函数是必须被调用的，创建对象时只有一个构造函数会被调用。

4.带参的构造函数除了能创建对象还有赋值的功能。

5.构造函数允许重载

注意：一旦用户自定义构造函数，系统就不会自动生成，构造函数要被声明为public属性。

#include <iostream>

using namespace std;

class A

{

private:

int m_a,m_b,m_c;

public:

void show()

{

cout<<"a"<<endl;

}

A(int a，int b)                                 //用户定义的含参构造函数

{

}

}

三.初始化列表：以上面的程序为例：

A::A(int a,int b):m_a(a),m_b(b)

{

}

也可以在构造函数内部对m_c进行初始化

A::A(int a,int b):m_a(a),m_b(b)

{

m_c=0;

}

四.this指针

作用：用来区分成员变量和函数参数,当成员变量的名称和函数参数的名称相同时要用this指针。

特点：1.this指针只能在成员内部函数使用，它是一个 const 指针，它指向当前对象，通过它可以访问当前对象的所有成员，对象被创建后才会给this指针赋值。

2.this 实际上是成员函数的一个形参，在调用成员函数时将对象的地址作为实参传递给 this。不过 this 这个形参是隐式的，它并不出现在代码中，而是在编译阶段由编译器默默地将它添加到参数列表中，this 作为隐式形参，本质上是成员函数的局部变量，所以只能用在成员函数的内部，并且只有在通过对象调用成员函数时才给 this 赋值。

注意：this指针不能在static修饰的函数中使用

例如：

class A

{

private:

int a,b;

public:

void show(int a,int b)

{

this->a=a;     //this指向的a是成员变量a

this->b=b;

}

}

五.析构函数

特点：1.名字是在类名前加一个~符号，无返回值，无参数

2.不能被重载

3.一个类只有一个析构函数。

作用：释放分配的内存，关闭打开的文件等

调用时机：1.在栈上创建的对象--->函数运行结束后调用；

2.在堆上创建的对象：《1》有delete时：函数运行结束后调用

                                         《2》无delete时不调用

3.全局对象在程序结束后调用析构函数，而局部对象在函数结束后调用析构函数。

例如：

#include <iostream>
#include <string>
using namespace std;
class Demo{
public:
    Demo(string s);
    ~Demo();
private:
    string m_s;
};
Demo::Demo(string s): m_s(s){ }
Demo::~Demo(){ cout<<m_s<<endl; }
void func(){
    //局部对象
    Demo obj1("1");
}
//全局对象
Demo obj2("2");
int main(){
    //局部对象
    Demo obj3("3");
    //new创建的对象
    Demo *pobj4 = new Demo("4");
    func();
    cout<<"main"<<endl;
  
    return 0;
}

输出结果为1  main   3   2

六.关键字

static：修饰静态成员变量或者静态成员函数，静态成员变量需要先在全局部分初始化，初始化方式有三种方式：

1.对象名.静态成员变量名

2.对象指针->静态成员变量名

3.类名：：静态成员变量名

例如：int A:：：m_a=0;

            a.m_a=0;

特点：静态成员函数只能访问静态成员变量或静态成员函数，普通成员函数可以任意访问。

注意：1.static成员变量不占用对象的内存，而是在所有对象之外开辟内存，即便不创建对象也可以访问

2.静态成员函数在声明处加static,在定义时不能加static.

const：修饰对象时在前面，修饰函数时在后面

例如：const  class  object(params);

char *getname() const;

用法：                                        访问普通成员变量        访问普通成员函数        修改普通成员       访问const成员变量       访问const成员函数      修改const成员变量

                   const函数                                 √                              ×                                   ×                                       √                                 √                                     ×

                   const对象                                 √                              ×                                   ×                                        √                                 √                                    ×

注意：1.const修饰的成员变量只能在初始化列表中初始化

七.友元函数

作用：借助友元可以使得其他类中的成员函数及全局范围内的函数访问当前类的private成员

例如：

例1：

class A

{

private:

int m_a;

public:

void frend show(A *a);

}

void show(A *a)     //不是A的成员函数却可以访问A的私有成员变量

{

cout<<a->m_a<<endl;

}

例2：

class B;

class A

{

private:

int m_a;

public:

void friend show(B *b);

}

class B

{

private:

int m_b;

}

void A::show(B *b)   //A的成员函数却可以访问B的私有成员变量

{

cout<<b->m_b<<endl;

}

终于总结完了，累累累！！！！