03C++类和对象

类与对象

1.结构体struct

————————与C语言差异很大区别如下

在C++中，struct可以拥有静态成员，可以从java角度去理解。

2.对象理解

C++是面向对象语言，现代强大的语言大部分都是面向对象语言，比如java/javascript/go/python等等。

可以简单理解：某类事物的集合，比如房子，房子里面有电视，有冰箱，有床，房子的年龄，房子的名称等等，房子是类，里面的东西叫做成员或属性。

#include <iostream>
using namespace std;
class House
{
public:
    string refrigerator;
    string bed;
    int age;
    string name;

    void say()
    {
        cout << name << age << bed << refrigerator << endl;
    }
};
int main(int argc, char const *argv[])
{
    House house;
    house.age = 20;
    house.name = "碧桂园";
    house.bed = "席梦思";
    house.refrigerator = "haier";
    house.say();
    system("pause");
    return 0;
}

3.struct和class区别

1.struct默认是public ，class默认是privete

2.定义方式不同，struct兼容了c语言的特性, class没有

A a = {'p', 7, 451.154};//struct对，class需要看编译器，主流时可以地，隐式转换法

4.类成员变量和函数

java中， final来指示函数为内联函数。 koltin/C++中通过inline。

内联优势：针对频繁被调用，代码量又不多的函数，明显减少时间的消耗。

内联缺点：占用内存，特别是代码量特别多的函数。

#include <iostream>
using namespace std;

class House
{
public:
    string refrigerator;
    string bed;
    int age;
    string name;
    void say();//
};

inline void House::say()
{
    cout << name << age << bed << refrigerator << endl;
}

int main(int argc, char const *argv[])
{
    House house;
    house.age = 20;
    house.name = "碧桂园";
    house.bed = "席梦思";
    house.refrigerator = "haier";
    house.say();
    system("pause");
    return 0;
}

5.类权限的封装prIvate/public

#include <iostream>
using namespace std;
class House
{
private: //默认是private，直到遇到public/protect为止
    string m_refrigerator;
    string m_bed;
    int m_age;
    string m_name;
    int m_date;

public:
    void setRefrigerator(string refrigerator);
    void setBed(string bed);
    void setAge(int age);
    void say();
};

void House::setRefrigerator(string refrigerator)
{
    m_refrigerator = refrigerator;
}

void House::setBed(string bed)
{
    m_bed = bed;
}

void House::setAge(int age)
{
    m_age = age;
}

void House::say()
{
       cout << m_refrigerator << m_age << m_bed << m_refrigerator << m_name << m_date << endl;
}


int main(int argc, char const *argv[])
{
    House house;
    house.setRefrigerator("haier");
    house.setAge(20);
    house.setBed("席梦思");
    house.say();
    system("pause");
    return 0;
}

注意：与java一样，会默认给类里面的成员赋值，int 默认值为0，string为“”；

6.C++对象内存模型

其实本质是与java一样，编译器会将成员变量和成员函数分开存储，分别为每个对象的成员变量分配内存，所有对象公用一组成员函数。

这样做的优点：节省内存，只需要改变类对象的指针，自然直到所指向的类对象的成员（函数编译原理和成员函数的实现）。

注意：成员函数在 代码区分配内存， 类对象可能在栈或者在堆， java中除了基本对象，都是在堆中生成，与C++不同。

7.构造函数

构造函数，有三种类型，默认无参构造、有参构造、拷贝构造（默认有）

本质上与java一致：默认无参构造只有一个，拷贝构造也只有一个（java中都是默认的，自己重写不了）

1.默认无参构造，当有有参构造时，默认不提供无参构造

2.默认有拷贝构造，当有拷贝构造时，默认不提供拷贝构造

#include <iostream>
using namespace std;

class Student
{
public:
    string m_name;
    int m_age;

public:
    Student();//无参
    Student(string name, int age); //有参
    Student(const Student &stu); //引用，拷贝构造
    void show();
};

Student::Student()
{
}
Student::Student(string name, int age)
{
    m_name = name;
    m_age = age;
}

Student::Student(const Student &stu) //拷贝构造
{
    m_name = stu.m_name;
    m_age = stu.m_age;
}

void Student::show()
{
    cout << m_name << m_age << endl;
}

int main(int argc, char const *argv[])
{
    Student stu; // 默认调用无参构造，声明并定义,extern只声明，一般全局使用地使用
    stu.m_age = 20;
    stu.m_name = "zhangsan";

    Student stu2("lisi",10);//有参构造

    Student stu3(stu2); //拷贝构造
    system("pause");
    return 0;
}

8.类初始化

int main(int argc, char const *argv[])
{
    Student stu("lisi", 30);//第一种
    Student stu2 = Student("zhangsan", 20);//第二种，匿名对象再完成初始化以及当前语句执行完之后，系统会立即回收到匿名对象。
    Student stu4(stu2);
    Student stu3 = {"wangwu", 20};//第三种
    Student stu5 = stu3;//拷贝，与java类型,第三种
    cout << stu3.m_age << endl;
    system("pause");
    return 0;
}

三种方式有什么区别：特别时第二种方式。

匿名对象特点：再完成初始化以及当前语句执行完之后，系统会立即回收到匿名对象。

分析下第二种： Student stu2 = Student(“zhangsan”, 20);

第一步：Student(“zhangsan”, 20); 产生一个匿名对象，第二步：然后再通过拷贝构造。本身逻辑应该是这个，会产生两个对象。

不过由于现代编译器对这一块进行了优化，当前也只会产生一个对象，匿名对象直接使用。

#include <iostream>
using namespace std;
class Student
{
public:
    string m_name;//默认会赋值 “”
    int m_age;//默认会赋值0

public:
    Student();                     //无参
    Student(string name, int age); //有参
    Student(const Student &stu);   //引用，拷贝构造
    ~Student();                    //析构函数
    void show();
};

Student::Student()
{
}
Student::Student(string name, int age)
{
    m_name = name;
    m_age = age;
}

Student::Student(const Student &stu)
{
    cout << "拷贝被执行" << endl;
    m_name = stu.m_name;
    m_age = stu.m_age;
}

void Student::show()
{
    cout << m_name << m_age << endl;
}

Student::~Student()
{
    cout << "析构被执行" << endl;
}

int main(int argc, char const *argv[])
{
    Student("zhangsan", 30);
    Student stu2 = Student("zhangsan", 20);//只会有一个对象产生
    cout << stu2.m_name << endl;
    // Student(stu2);//这种匿名对象拷贝不要使用，编译器会当作是声明 Student stu2;
    system("pause");
    return 0;
}

out << “析构被执行” << endl;
}

int main(int argc, char const *argv[])
{
Student(“zhangsan”, 30);
Student stu2 = Student(“zhangsan”, 20);//只会有一个对象产生
cout << stu2.m_name << endl;
// Student(stu2);//这种匿名对象拷贝不要使用，编译器会当作是声明 Student stu2;
system(“pause”);
return 0;
}