//假設聲明已經定義。邊不會生成classclassA{private:inta;intb;public://拷貝構造的規則,有兩種方式實現初始化//1、一個是通過在后面:a(x),b(y)的方式實現初始化//2、另外一種初始化的" />

亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

拷貝構造函數,深拷貝,大約delete和default相

系統 1645 0
??

1. 拷貝構造

// 拷貝構造的規則 , 有兩種方式實現初始化。

//1 、一個是通過在后面 :a(x),b(y) 的方式實現初始化。

//2 、另外一種初始化的方式是直接在構造方法里面實現初始化。

案比例如以下:

      #include<iostream>

//假設聲明已經定義。邊不會生成
class classA
{
private:
	int a;
	int b;
public:
	//拷貝構造的規則,有兩種方式實現初始化
	//1、一個是通過在后面:a(x),b(y)的方式實現初始化
	//2、另外一種初始化的方式是直接在構造方法里面實現初始化
	classA(int x,int y)//:a(x),b(y)
	{
		a = x;
		b = y;
	}
	void print()
	{
		std::cout << a << " " << b << std::endl;
	}
};

void main()
{
	classA class1(10,100);//編譯器會默認生成默認的構造函數
	classA class2(class1);//編譯器會生成默認的拷貝構造函數
	class1.print();
	//默認的拷貝構造函數,說明能夠通過類的方式實現淺拷貝
	class2.print();

	std::cin.get();
}

    

2. 深度拷貝。使用深度拷貝的時候要將分配內存。這是當中的關鍵點。

      #define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include<string>
class string
{
public:
	char *p;
	int length;
	string(int num, char *str)
	{
		//獲取長度,分配內存。拷貝內容
		length = num;
		p = new char[length]; //深度拷貝的時候,要分配內存
		memset(p, 0, length);//
		strcpy(p, str);
	}
	string(const string & string1)
	{
		this->p = new char[string1.length];
		this->length = string1.length;
		//將開辟的內存中的內容賦值為0
		memset(this->p, 0, this->length);
		strcpy(this->p, string1.p);
	}
	~string()
	{
		delete[] p;//刪除的時候要帶上[]
	}
};
void main()
{
	string *pstr1 = new string(10, "hello");
	std::cout << pstr1->p << std::endl;
	string *pstr2 = new string(*pstr1);
	delete pstr1;
	std::cout << pstr2->p << std::endl;
	std::cin.get();
}

    

上面的執行結果是:

      void main()
{
	string str1(10,"hello");
	std::cout << str1.p << std::endl;

	string str2(str1); //這里說明能夠通過
	std::cout << str2.p << std::endl;

	std::cin.get();
}

    

執行結果例如以下:

3. 關于 delete default 相關的操作

A:delete 能夠禁用默認生成的函數。禁用構造能夠無法實例化,禁用拷貝構造,能夠實現禁止別人拷貝你。

B:default 的作用是讓函數默認存在。

      myclassA::myclassA(void);   //嘗試引用已刪除的函數
myclassA() = delete;        //默認刪除構造函數。無法實例化
myclassA(const myclassA &) = delete;  //拷貝構造函數
myclassA(const myclassA &) = default;

~myclassA();

void main()
{
	//myclassA myclassa1;
	//myclassA myclassa2(myclassa1);
    //myclassA myclassa3 = myclassa1;   //重載了=,依據類型
	//myclassA a1;
}

    

4.explicit.cpp

      #include <iostream>
#include <array>

class  classobj
{
public:
	int num;
public:
	//使用有參構造,使用explicit
	explicit classobj(int data)
	{
		this->num = data;
		std::cout << "被構造" << num << std::endl;
	}
	~classobj()
	{
		std::cout << "被銷毀" << num << std::endl;
	}
protected:
private:
};

void main()
{
	//C 語言風格的數組,構造一個數組,銷毀一個數組
	classobj obj(0);//單獨獨有構造函數
	//C語言風格數組構造方式
	classobj objx[3] = { classobj(1), classobj(2), classobj(3) };
	classobj (*ppobjA)[3] = &objx; //指向數組的指針
	classobj *pobj(new classobj(4));

	classobj * ppobj[3];//數組。每個元素都是指針
	ppobj[0] = new classobj(5);
	ppobj[1] = new classobj(6);
	ppobj[2] = new classobj(7);

	std::cin.get();
}

    

執行結果例如以下:

拷貝構造函數,深拷貝,大約delete和default相關業務,explicit,給定初始類,構造函數和析構函數,成員函數和內聯函數,關于記憶儲存,默認參數,靜態功能和正常功能,const功能,朋友

?

5. 類的賦初值

第一種方式 : ? 在構造函數后面通過加上 ? : 變量名 ( 變量值 )

另外一種方式:在構造函數,函數體里面寫上 ?? 變量名 = 變量值 ;

第三種方式:類名 對象名 = 變量值

      #include <iostream>
#include <array>

class  classobj
{
public:
	int num;
public:
	//使用有參構造,使用explicit
	classobj(int data)
	{
		this->num = data;
		std::cout << "被構造" << num << std::endl;
	}
	~classobj()
	{
		std::cout << "被銷毀" << num << std::endl;
	}
protected:
private:
};

void main()
{
	classobj num = 5;//賦值號,類型轉換
	num = 6;         //說明類的初始化能夠通過等號的方式賦值
	classobj data(7);

	classobj obj(8); //創建對象必須合適的構造函數
	
	//C++風格數組的作用
	classobj *p = new classobj(9);
	std::array<classobj, 2> myarray = { obj, *p };

	std::cin.get();
}

    

執行結果是:

賦值案例 2

      #include <iostream>

class myclass
{
public:
	int num;
public:
	myclass():num(4)//初始化第一種方式
	{
		//num = 10; //另外一種方式
	}
	myclass(int data)  //構造函數能夠重載
	{
		std::cout << "class create by data: " << data << std::endl;
		num = data;
	}
	~myclass()
	{
		std::cout << "class delete";
	}
};

void run()
{
	myclass myclass1(10);
	myclass myclass2 = 102;
	myclass *p = new myclass(103);
	myclass *p2(new myclass(104));
	std::cout << (*p).num << std::endl;
	//std::cout << myclass1.num << std::endl;
};

void main()
{
	run();
	
	std::cin.get();
}

    

執行結果例如以下:

拷貝構造函數,深拷貝,大約delete和default相關業務,explicit,給定初始類,構造函數和析構函數,成員函數和內聯函數,關于記憶儲存,默認參數,靜態功能和正常功能,const功能,朋友

6. 構造函數與析構函數

A :系統自己主動生成了構造函數與析構函數

B :被包括的,最先調用構造。最后調用析構

C :包括別人的,最后調用構造,最先調用析構

案例說明:

      #include <iostream>

//系統自己主動給你生成了構造函數與析構函數
//被包括的。最先分配,最后釋放(這里是調用析構不是釋放內存)
//包括別人的,最后分配,最先釋放(這里是調用析構不是釋放內存)

class fushu
{
public:
	fushu();
	~fushu();
};

fushu::fushu()
{
	std::cout << "fushu構建" << std::endl;
}

fushu::~fushu()
{
	std::cout << "fushu銷毀" << std::endl;
}

class math
{
public:
	fushu fushu1;//一個類調用另外一個類
	math()
	{
		std::cout << "math構建" << std::endl;
	}
	~math()
	{
		std::cout << "math銷毀" << std::endl;
	}
};

void go()
{
	math math1;
}

void main()
{
	go();

	std::cin.get();
}

    

執行結果截圖:

分析,上面的 math 類調用 fushu 這個類,這個結果說明了 A,B,C.

7. 成員函數和內聯函數

A: 內聯函數一般在頭文件里。

編寫頭文件:

      #pragma once
#include <iostream>
class fushu
{
public:
	int x;
	int y;
public:
	fushu();
	~fushu();
	void show();
	//顯示內聯
	inline void showall(int x, int y);
	//編譯器優化,默認隱式內聯
	void setxy(int x, int y);
	void show(int x,int y);
};

//內聯函數原則上放在頭文件,而且在實現內聯函數的時候。去掉inline標識符
//內聯函數須要展開,(VS2013是要求放在頭文件的)
void fushu::showall(int x, int y)
{
	std::cout << "頭文件里內聯函數showall:this->x = " 
		<<(this->x = x) << "this->y =" <<(this->y = y) << std::endl;
}

    

頭文件里的實現類

      #include "fushu.h"
//::這個符號卡面必須是類或者命名空間

fushu::fushu()
{
	std::cout << "對象被創建" << std::endl;
}

fushu::~fushu()
{
	std::cout << "對象被銷毀" << std::endl;
}
//類調用成員函數。須要明白那個類的對象調用

void fushu::show()
{
	std::cout << "show" << std::endl;
}

void   fushu::setxy(int x, int y)//編譯器優化,默認隱式內聯
{
	this->x = x;
	this->y = y;
	std::cout << "實現類中setxy:(this->x)= "<<(this->x)<< " (this->y)=" << (this->y) << std::endl;
}

void  fushu::show(int x, int y)
{
	std::cout << "實現類中show:(this->x)= " << (this->x) << " (this->y)=" << (this->y) << std::endl;
}

    

調用函數:

      #include<iostream>
#include "fushu.h"

void stackrun()
{
	fushu fushu1;//對象在棧上
	fushu1.show();
}

void heaprun()
{
	fushu *pfushu = new fushu;//對象在堆上
	pfushu->show();
	pfushu->showall(10, 9);
	pfushu->setxy(19, 29);
	pfushu->show(1, 2);

	//內部成員函數重載,函數指針。明白了參數
	delete pfushu;
}

void main()
{
	heaprun();

	std::cin.get();
}

    

7. 關于內存

      #include <iostream>

class myclass
{
public:
	int num;
	int data;
	int *p;
	const int coint;//常量必須在構造函數中初始化
	int & myint;    //引用必須初始化,在構造函數中初始化
	static int shu; //聲明。在外部進行初始化
	static const int dashu;
public:
	static void go(){}
	void run(){}
	//常量,引用。必須重載構造函數初始化
	myclass(int a, int b) :myint(a), coint(b)
	{
		//引用就是共用地址,常量新開辟備份機制
		std::cout << &a << "  " << &b << std::endl;
		std::cout << &myint << "  " << &coint << std::endl;

		const int *p = &coint;//地址
		std::cout << *p << "   " << coint << std::endl;
		int *px = const_cast<int *>(p);//去掉const轉換
		*px = 12;
		std::cout << coint << "  " << *px << std::endl;
	}
	~myclass(){}
};

//對于靜態的變量要在類外面初始化
int myclass::shu = 0;
//對于靜態的變量要在類外面初始化
const int myclass::dashu = 20;

void main()
{
	const int *px = &(myclass::dashu);
	std::cout << px << std::endl;
	int *p = const_cast<int *>(px);
	//靜態常量區能夠訪問。不能夠改動,所以以下的方式是錯誤的
	//*p = 123;
	std::cout << *px << "  " << *p << "   " << myclass::dashu;

	std::cin.get();
}

    

執行結果是:

8. 關于默認參數

      #include<iostream>

class goodclass
{
public:
	int num = 1;//默認初始化的值,C++11特定
	const int data = 90;//const,這樣的方式初始化就不須要寫構造函數了
public:
	static void show(goodclass good1)
	{
		std::cout << good1.num << "  " << good1.data << std::endl;
	}
};
//類中的const默認還是能夠改動,與C語言const一致
void main()
{
	goodclass good1;
	goodclass::show(good1);

	const int *px = &(good1.data); //這里表示指向常量的值
	std::cout << px << std::endl;
	int *p = const_cast<int *> (px);//取消常量屬性
	*p = 123;
	std::cout << *px << "  " << *p << "   " << good1.data << std::endl;
	goodclass::show(good1);

	std::cin.get();
}

    

執行結果:

9. 在類里面定義一個靜態變量。實現計數并限制 QT 中彈出窗口,建立 QMainWindow QT 項目。

(假設想讓 QT 支持 C++11 的語法,須要在 QT 項目的 pro 文件里增加: CONFIG += c++11 ,能夠再最后面附加上)當中 main.cpp 的代碼是:

      
        
        
      
      
        #include "mainwindow.h"
#include <QApplication>
#include <QDebug>   //這個頭文件要加上
class mywindow
{
  public:
    mainwindow *p;   //這里的mainwidow標識的是窗口類
    static int num;  //全部類都能夠訪問靜態區
    mywindow()
    {
        if(num > 2)//靜態類成員進行成員
        {}
        else
        {
            num++;
            qDebug()<<"create";
            this->p = new mainwindow;//實例化一個對象
            this->p->show();//讓這個窗口顯示
        }
    }
    ~mywindow()
    {
        qDebug() << "delete";
        delete this->p;
    }
};

//對靜態變量賦初值
int mywindow::num = 0;

void run()
{
    mywindow my1;//棧上
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    mywindow *pwindow = new mywindow;
    qDebug() << mywindow::num;//通過這行打印出次數

    //以下是低嗎快
    {
        mywindow  *pwindow=new mywindow;
        qDebug() << pwindow->num;
    }
    {
        mywindow  *pwindow=new mywindow;
        qDebug() << pwindow->num;
    }
    {
        mywindow  *pwindow=new mywindow;
        qDebug() << pwindow->num;
    }
    return a.exec();
}

      

      
      
    
      
        
          拷貝構造函數,深拷貝,大約delete和default相關業務,explicit,給定初始類,構造函數和析構函數,成員函數和內聯函數,關于記憶儲存,默認參數,靜態功能和正常功能,const功能,朋友
        
      
    

10. 靜態函數和普通函數

      
        
        
      
      
        #include "mainwindow.h"
#include <QApplication>
#include <stdlib.h>
#include <QDebug>

class mywindow
{
public:
    MainWindow w;

public:
    static void run()  //由于加了static。所以不用實例化就能夠用。
    {
        system("calc");
    }
    void notepad()
    {
        system("notepad");
    }
};

class mywindowW
{
public:
    MainWindow w;  //繼承
    int #
public:
    mywindowW(int data):num(data)  //給data初始化
    {}
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    mywindow mywindow1;
    mywindow1.w.show();

    mywindow1.run();     //第一種調用方式
    mywindow1.notepad();
    //mywindow1::notepad();//這樣的方式不能夠直接地調用
    mywindow::run();//不須要實例化的情況就能夠調用

    return a.exec();
}

      

執行結果是彈出計算器和記事本。

11. 函數默認參數,對于給含有默認參數的函數賦值的時候,參數的賦值將從左往右賦值給函數中的參數。

案比例如以下:

      #include "mainwindow.h"
#include <QApplication>

class mywindow
{
public:
    MainWindow w;
    MainWindow *p;

    //假設在調用的時候僅僅傳遞一個參數的時候,這個參數賦值給了str1
    void settitle(char *str1="XYZ",char *str2="THG")
    {
        w.setWindowTitle(str1);
        p->setWindowTitle(str2);
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    mywindow my1;
    my1.p=new MainWindow;
    my1.w.show();
    my1.p->show();
    //傳遞參數的時候,從左往右填充。比方以下的AHNJ將賦值給*str1
    //能夠僅僅傳遞一個參數,也能夠傳遞兩個參數
    my1.settitle("AHNJ");

    return a.exec();
}

    

執行結果例如以下:

拷貝構造函數,深拷貝,大約delete和default相關業務,explicit,給定初始類,構造函數和析構函數,成員函數和內聯函數,關于記憶儲存,默認參數,靜態功能和正常功能,const功能,朋友

12. 加了 const 之后函數和沒有加 const 變量的函數的差別:

新建 QT 項目,編寫代碼:



      #ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
    //以下是新加入的
public:
    int x;
    int y;
    mutable int z;//不受const成員函數的約束

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    void resetxy();//沒有const屬性,能夠改動成員變量
    void showxy() const;  //const,不能夠改動一般的成員變量

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H
編寫MainWindow的實現
#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::resetxy()
{
    this->x = 800;
    this->y = 600;
    resize(this->x,this->y);
}

void MainWindow::showxy() const
{
    //由于是加了const,所以不再能夠調用成員變量
    //this->x = 10;
    //由于沒有加上mutable。所以不能夠調用
    //this->y = 100;
    this->z = 1000;
}
調用main函數
#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;

    //重置窗體大小
    w.resetxy();

    w.show();

    return a.exec();
}

    

13. 關于友元函數。案比例如以下(不用改動 QT 的頭文件和頭文件的實現類):

      #include "mainwindow.h"
#include <QApplication>

//友元函數能夠訪問類中的私有變量。還能夠訪問私有函數
//友元函數聲明的時候要有friend,定義的時候不須要friend了
//定義友元的時候也能夠在內的內部
class mywindow
{
    MainWindow *p;
    void go()
    {
        system("notepad");
    }
    //聲明一個友元函數
    void  friend showwindow(mywindow * pwin);
};

//實現一個友元函數
void showwindow(mywindow *pwin)
{
    pwin->p=new MainWindow;

    pwin->p->show();
    pwin->go();
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    mywindow my1;

    // my1.p;
    showwindow(&my1);

    return a.exec();
}

    


14. 友元類,當指向了一個指針的時候一定要初始化。

否則將出現錯誤。以下的函數任然是 main.cpp 中的內容。

      #include "mainwindow.h"
#include <QApplication>

//被友元
class window
{
    MainWindow *p;
    void settitle()
    {
        this->p->setWindowTitle("1234");
    }
    friend class opwindow;//友元類
};

class opwindow
{
private:
    window pwin; //類的變量,指針能夠訪問類的全部私有成員與函數
    window *ppwin;//指針必須初始化,必須分配內存

public:
    void init()
    {
        //不初始化就是野指針,所以這里一定要初始化,不然會報錯
        ppwin = new window;
        ppwin->p = new MainWindow();
        ppwin->p->show();
    }
    void setstr()
    {
        ppwin->settitle();
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    opwindow opwindow1;
    opwindow1.init();
    opwindow1.setstr();//語法

    return a.exec();
}

    

友元類案例 2

頭文件 QT 項目:

      #ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    //重載
    MainWindow(const MainWindow & w)
    {
        MainWindow(0);
    }

    ~MainWindow();

private:
    Ui::MainWindow *ui;
    //友元類
    friend class window;
};

#endif // MAINWINDOW_H

main.cpp
#include "mainwindow.h"
#include <QApplication>

class window
{
public:
    MainWindow w;
    MainWindow *p;
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    window window1;
    window1.w.show();
    window1.p = new MainWindow(window1.w);
    window1.p->show();

    return a.exec();
}

    

?

?

版權聲明:本文博客原創文章。博客,未經同意,不得轉載。

拷貝構造函數,深拷貝,大約delete和default相關業務,explicit,給定初始類,構造函數和析構函數,成員函數和內聯函數,關于記憶儲存,默認參數,靜態功能和正常功能,const功能,朋友


更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 青草青在线免费视频 | 青青免费视频视频在线 | 久久福利精品 | 老司机午夜精品视频你懂的 | 手机看片日韩日韩 | 一级一片免费播放 | 国内永久第一免费福利视频 | 久久亚洲在线 | 亚洲精品tv久久久久久久久 | 欧美xxxxx性另类 | 男人叼女人的痛爽视频免费 | 美女久久久久久久久久久 | 国产尤物在线播放 | 亚洲免费一区 | 四虎影视在线永久免费观看 | 欧美国产片 | 美国免费三片在线观看 | 国产网红自拍 | 四虎影院2019| sese视频在线 | 久草在在线 | 久久综合给合久久狠狠狠97色 | 亚洲va久久久噜噜噜久久男同 | 人人骚 | 福利影院在线看 | 欧美视频一区二区三区在线观看 | 久草新免费 | 亚洲精品欧美精品日韩精品 | 青青青国产在线手机免费观看 | 欧美国产影院 | 色网址在线 | 一区二区中文字幕在线观看 | 国产精品免费精品自在线观看 | 国产尤物在线视频 | 911国产在线观看精品 | 日本久久网 | 性生活视频网址 | 97精品国产自在现线免费 | 国产精品高清在线观看 | 亚洲精品乱码久久久久 | 亚洲一级片在线观看 |