[C++知识库]第一周OOP1

类

类是面向对象程序设计基础，是c++封装的基本单元。在类中说明的要么是数据成员，要么是成员函数，它们可以是public:,protected: ,private:的。在C++中，默认是private。

一个类对象所占据的内存空间由数据成员决定，成员函数不占据对象内存空间。

class Date
{
int month;
int year;
int day;
//数据成员day 的全名是Date:: day.
public:
void set(int a,int b, int c)
/*set 全名是Date::set(int a,int b, int c)。
类名指出set是自己的成员函数，而不是其他类的。*/

//成员函数可以在类外部定义，但必须加上“类名::”
{
month =a;
year=b;
day=c;
//一个类的所有成员位于这个类的作用域内，一个类的任何成员都可访问本类的任何其它成员。
}
};

当在外部声明类的成员函数时，类名必须加在函数名之前，不在返回类型之前。

class Date
{······};
void Date::set(int a, int b, int c)
{
month=a;
year=b;
day=c;
}

成员函数可以重载，如果两个类有成员函数同名就不是重载。

数据成员的隐藏：

#include<iostream>
using namespace std;
class test//类可以在函数中定义（局部类），作用域在函数块中。
//局部类的成员函数必须在类内部定义。
{
    
    public:
    void a()
    {
        m=2;
    }
    void b()
    {
        int m=3;
    }
    int m=1;
};
int main()
{
    test x;
    cout<<x.m<<endl;    //输出1
    x.b();   //函数中定义了同名的局部作用域变量，把m隐藏了
    cout<<x.m<<endl;    //输出1
    x.a();
    cout<<x.m<<endl;    //输出2
}

类名遮挡：类名允许与其他变量名或函数名相同。?

类名、变量名、函数名被后面定义的遮挡

//类名被遮挡，可以在类名前加“class”

//非类型名被遮挡，可在非类型名前加“::“

结构

结构是用户自定义的新数据类型，结构中的数据变量成为该结构的数据成员。

声明结构：在c++中，结构是用struct 声明的类，默认是public

struct student
{
int id;
string name;
float weight;
};  //注意“;"

声明结构不分配内存，内存分配发生在定义这个新数据类型的变量中。在C中不可有成员函数，而在C++中可以有。

结构成员的访问：用结构名+点操作符"."（也称结构成员操作符）来访问结构中的成员。或者结构指针+? ”->"。

结构赋值：不同结构名的变量之间不可赋值，即使二者包含相同的数据成员。结构比较大时，用引用或指针传递可以节省时间和空间。

构造函数

c++中与类同名的成员函数是构造函数，在类的对象创建时自动被调用

class test
{
    int *a=new int;
    public:
    test()//构造函数无返回类型；无参数的构造函数称为默认构造函数
/*可以通过构造函数设定数据成员默认值*/
    {
        *a=2;
        return; //不能返回值，但可以有无值返回语句return。
    }
    ~test()    //析构函数，在构造函数名前加”~“
    {
        delete a;
    }
//当主函数运行到}结束时，析构函数被调用，最后创建的对象最先调用

};

?C++中每个类必须有构造函数，若没有声明构造函数，则c++提供一个没有参数的默认构造函数，仅负责创建对象空间。

类定义是不分配空间和初始化的，类的定义中不能创建对象

class object1
{
    int a;
};
class object2
{
    object1 b(1);//”错误“这是创建对象语句，不是类定义中允许的声明数据成员形式
                 /*类的定义不调用构造函数*/
    object1 b;   //正确  类成员
};

类成员： 若类中有其他类成员，构造函数冒号后面可以表示对数据成员构造函数调用

#include<iostream>
using namespace std;
class class1
{
    public:
    int a;
        class1(int b)
        {
            a=b;
        }
};
class class2
{
    public:
    class1 obj;
    class2(int num):obj(num)//如果是:obj(),则可以省略。*不可用"obj.a=num"  冒号后面若有多个表达式用逗号隔开。
    {}      //此时必须有{}
};
int main()
{
    class2 t(66);
    cout<<t.obj.a<<endl;  //输出66
}

声明一个变量并初始化有两种形式：

int main()
{
    int a=9;    //第一种
    int a(9);   //第二种
//赋值时只有一种
    int b;  b=8;
    int c;  c(8);   //error
}

构造对象的顺序：

#include<iostream>
using namespace std;
int main()
{
    {
    int a=2;
    if(a==2)
    goto go;  //error
    int b=0;
    go:
    cout<<a<<endl;
    }   /*局部和静态对象以声明的顺序构造
    此块在C中可以接受，在C++编译器中会报错
    所有变量和对象在函数开始执行时统一定义，
    统一定义的顺序是这些变量和对象在函数中出现的顺序。*/

    /*所有全局对象在main执行前已经被构造
    全局对象构造时无特殊顺序
    所以尽量不要让一个全局对象访问另一个全局对象*/
    {
        class test 
        {
            int a=1,b=1;
            public:
            test(int n1,int n2): b(n1),a(n2+b)
            {
                cout<<a<<"  "<<b<<endl; //输出：4201218（随机值）  2  ？
            }

        };   //成员以其在类中声明的顺序构造，而不是按构造函数中冒号后面的顺序。
        test aa(2,2);
    }
}