C++第七节课作业

1.C++类的组合

  以另一个类的对象为数据成员

  必须使用初始化参数列表的方式去初始化 

#include<iostream>
#include<string>
using namespace std;
class Fox
{

public:
    Fox( string name, int age) :name1(name), age(age) {}//构造函数

protected:
    void printf1()
    {
        cout << name1 << age << endl;
    }
    string name1;
    int age;
};
class Fox2
{

public:
    Fox2(string yueyuename, int yueyueage, string fox2name) :yueyue(yueyuename, yueyueage) 
    {
      this->name = fox2name;
     //yueyue.printf1();//类外无法访问保护属性
    }//以另一个类的对象为数据成员
    Fox2(string Name) :name(Name), yueyue("默认名字", 18) {}
    void printdata() 
    {
        cout << name << endl;
    
    }
 
protected:
    string name;
    Fox yueyue;

};



int main()
{
    Fox2 susu("狐狸");
    Fox2 susu2("苏苏",3,"月月");
    
    while (1);
    return 0;
}

 类的组合构造顺序只和定义对象顺序的有关，和初始化参数列表无参。

#include<iostream>
#include<string>
using namespace std;
class A
{
public:
	A(string name) :name(name) 
	{
		cout << name << endl;
	}
	string name;

};

class B
{
public:
	B(string name) :name(name)
	{
		cout << name << endl;
	}
	string name;


};
class C
{
public:
	C(string name) :name(name)
	{
		cout << name << endl;
	}
	string name;

};
class D
{
public:
	D(string namea, string nameb,string namec) :b(nameb),c(namec), a(namea)
	{
		cout << this->name << endl;
	}
	B b;//b先构造
	A a;

	C c;
	string name;

};

int main()
{
	D d("狐狸1", "狐狸2", "狐狸3");
	//所以先打印狐狸2，在打印狐狸1，狐狸3

	return 0;
}

2.类种类

 类中类依旧受权限限定

 访问方式 需要类名限定

#include<iostream>
using namespace std;
struct Node
{
    int data;
    Node* next;
    Node() //无参数构造函数时下一个指向空
    {
      this->next = nullptr;
    }
    Node(int data)//构造有参数函数
    {
        this->next = nullptr;
        this->data = data;
    }
};
class List
{
public:
    List()
    {
        headNode = new Node;
    }
    void instrhead(int data)
    {
        Node* newNode = new Node(data);
        newNode->next = headNode->next;
        headNode->next = newNode;
    }

protected:
    Node* headNode;
public: //迭代器 类模仿指针的方式
        

    class iterator
    {
    public:
        iterator(Node* pMove = nullptr) :pMove(pMove) {}//构建一个对象 它指向的空
        void operator=(Node* pMove) //重载运算符等号，让类能赋值
        {
            this->pMove = pMove;
        }
        bool operator!=(Node* pMove) //如果不等于放回真
        {
            return this->pMove != pMove;
        }
        iterator operator++()//重载++ 运算符，放回的是下一个的地址
        {
            pMove = pMove->next;
            return iterator(pMove);
        }
        
        Node*& operator*()//返回的是一个Node*的指针
        {
            return pMove;
        }
    protected:
        Node* pMove;
    };
    Node* begin()  //开始的位置
    {
        return headNode->next;
    }
    Node* end()//结束的位置
    {
        return nullptr;
    }
};


int main()
{
    List list;
    for (int i = 0; i < 3; i++) {
        list.instrhead(i);//头部插入链表
    }
    List::iterator iter;
    for (iter = list.begin(); iter != list.end(); ++iter) //
    {
        cout << (*iter)->data;
    }

    return 0;
}



   

类中关于枚举类型

#include<iostream>
using namespace std;
//类中枚举类型

class  A
{
public:
	enum time { first, second };
protected:
	enum date { mon, sur, tus };
	//类中的枚举类型受权限限定
};
int main() 
{

	//cout << A::date::mon << endl; 类外不可以访问数据
	cout << A::time::first << endl;

}

C++默认构造函数

#include <iostream>
using namespace std;
class A
{
public:
	A() = default;//存在默认构造函数
	A(A& object) = default;//默认的拷贝构造
	//void print() = default;//没有默认的函数成员
	A& operator=(A& object) = default;//存在默认重载的运算符
	~A() = default;//存在默认析构函数
};
int main()
{
	A a;//默认构造函数
	A b = a;默认的拷贝构造
	A c;
	c = a; //默认重载的运算符
	return 0;
}

构造函数 2013没有移动语义的标准所以创建匿名对象时会调用拷贝构造，但2019不会调用拷贝构造，会直接转交所有权，不同版本有不同处理方式