C++ class struct

来源:https://www.cnblogs.com/yijieyufu/archive/2023/03/18/17229793.html
-Advertisement-
Play Games

本文已經收錄到Github倉庫，該倉庫包含電腦基礎、Java基礎、多線程、JVM、資料庫、Redis、Spring、Mybatis、SpringMVC、SpringBoot、分散式、微服務、設計模式、架構、校招社招分享等核心知識點，歡迎star~ Github地址：https://github.c ...


class and struct

目錄

前文

c++ 中的class 和struct

struct 預設為 public

class 預設為private

問題

左值引用，右值引用區別？

什麼時候需要定值淺拷貝和深拷貝的函數。

傳值和傳值的區別

對象與引用

引用的傳遞

返回引用就意味著是data[ind]的別名。 

using namespace std;

class Vector{
public:
    Vector(int n =100) : n(n),data(new int[n]){}
    int &at(int ind){return data[ind];}
private : 
    int n ; 
    int *data;
};

int main(){
    Vector arr;
    for(int i=0; i< 1; i++){
        arr.at(i) = i;
                
    }   
    return   0;  
}

對象 copy

實際上兩種copy是邏輯上的

class Vector{
public:
    Vector(int n =100) : n(n),data(new int[n]){}
    int &at(int ind){
        cout << "ind" << ind << endl;
        return data[ind];
    }   
    int &operator[](int ind) {return data[ind];}
    void output (int m = -1){
        if(m == -1)   m = n;    
        cout <<"Arr"  <<  this << endl;
        for(int i = 0; i < m; i++){
            cout << data[i] << " ";
        }
        cout << endl;
        return ;
    }   
private : 
    int n ; 
    int *data;
};

shallow copy

int main(){
    Vector arr;
    for(int i=0; i< 10; i++) arr[i]=i;
        arr.output(10);

    Vector arr2(arr);
    arr2.output(10);
    arr2[3]=1000;

    arr.output(10);
    arr2.output(10); 

    return   0;
}   

Arr0x7ffcddc92630  arr 
0 1 2 3 4 5 6 7 8 9 
Arr0x7ffcddc92620 arr 2
0 1 2 3 4 5 6 7 8 9 
Arr0x7ffcddc92630
0 1 2 1000 4 5 6 7 8 9 
Arr0x7ffcddc92620
0 1 2 1000 4 5 6 7 8 9 

  arr  {n=100 data=0x000002196c4ad400 {0} }  Vector
  arr2 {n=100 data=0x000002196c4ad400 {0} }  Vector
  vs 的debug 模式下 data

本代碼將arr 拷貝給了arr2 ，本身屬於兩個不同的對象。

既然屬於不同的對象，arr2的變動不應對arr1發生改變，但是事與願違 ，因為受拷貝行為的影響,依次性的拷貝，由於是指針域，拷貝了同一個存儲區的值。所以 arr2 發生更改，arr1 也會發生更改。

☕如果copy 的對象是指針類型時，這個方式就無法適用了.

depthcopy

指針類型並非是賦值關係，存arr2 應該是一個額外的存儲區。

memcpy(data,a.data,sizeof(T) *n);

當前方法在一定的簡單類型的場景下可以進行深拷貝，如果類型中存在了指針類型則也會出現兩個指針指向同一個地址的的情況。

#include<iostream>                                                                       
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
#define  BEGINS(x) namespace x {//begin of namespace 
#define  ENDS(x)} //end of namespace x 

BEGINS(xxx)
class A  {
    public :                                                                             
        int x , y;
};

ostream &operator<<(ostream &out ,const A &a){
    out <<  "(" << a.x <<   " , " << a.y << ")";
    return out;
}
template<typename T>
class Vector{                                                                            
public:
    Vector(int n =100) : n(n),data(new T[n]){}

    Vector (const Vector &a): n(a.n){
        // 實現深拷貝
        data = new T[n];
        /*
           for(int i = 0; i < n; i++){
           data[i]=a.data[i];
           } */
        //實現以上的效果
        //1 : memcpy 可能是複製類型是複雜類型的對象
        memcpy(data,a.data,sizeof(T) *n);
        return ;
    }
    T &at(int ind){
        cout << "ind" << ind << endl;
        return data[ind];
    }

    T &operator[](int ind) {return data[ind];}
    void output (int m = -1){
        if(m == -1)   m = n;    
        cout << "Arr size " << sizeof(data) << " "  <<  this << endl;

        for(int i = 0; i < m; i++){
            cout << data[i] << " ";
        }
        cout << endl;
        return ;
    }
private : 
    int n ;
    T *data;
};
ENDS(xxx)

簡單類型

BEGINS(test1)
using namespace xxx; 
    int main(){
         Vector<int>  arr;
        for(int i=0; i< 10; i++) arr[i]=i;
        arr.output(10);
        Vector<int>  arr2(arr);
        arr2.output(10);                                                                 
        arr2[3]=1000;
        arr.output(10);
        arr2.output(10);
        return   0;
    }
ENDS(test1)

Arr size 8 0x7ffc86e546d0
0 1 2 3 4 5 6 7 8 9 
Arr size 8 0x7ffc86e546c0
0 1 2 3 4 5 6 7 8 9 
Arr size 8 0x7ffc86e546d0
0 1 2 3 4 5 6 7 8 9 
Arr size 8 0x7ffc86e546c0
0 1 2 1000 4 5 6 7 8 9

☕由結果可以看到，很顯然在copy後並沒有影響arr1的指針域

複雜類型

BEGINS(test2)
using namespace xxx;
                                                                                         
int main(){
    Vector<A> arr1;
    for(int i =  0; i < 10; i++){
        arr1[i].x = i;
        arr1[i].y = 2 * i;
    }   
    arr1.output(10);
    Vector<A> arr2(arr1);
    arr2[3] = (A){4, 100};
    arr2.output(10);
    arr1.output(10);
    return 0;
}
ENDS(test2)

Arr size 8 0x7ffc053fdeb0   //原 
(0 , 0) (1 , 2) (2 , 4) (3 , 6) (4 , 8) (5 , 10) (6 , 12) (7 , 14) (8 , 16) (9 , 18) 
Arr size 8 0x7ffc053fdea0    
(0 , 0) (1 , 2) (2 , 4) (4 , 100) (4 , 8) (5 , 10) (6 , 12) (7 , 14) (8 , 16) (9 , 18) 
Arr size 8 0x7ffc053fdeb0
(0 , 0) (1 , 2) (2 , 4) (3 , 6) (4 , 8) (5 , 10) (6 , 12) (7 , 14) (8 , 16) (9 , 18)

☕在不涉及對象中的(指針類型)(其中類型不需要深拷貝的場景)的情況下，可以實現深拷貝。

指針類型的拷貝

memcpy 是無法做到深拷貝的，無法完美的遷移。

BEGINS(test3)
using namespace xxx;

int main(){
   Vector<Vector<int>> arr1;
   Vector<Vector<int>> arr2(arr1);

   arr2[2][2]=1000;
   for(int i =0; i <3 ; i++){
       arr1[i].output(3);
       cout <<endl;
   }
    for(int i =0; i <3 ; i++){
       arr2[i].output(3);
       cout <<endl;
   }

   return 0;
}
ENDS(test3)

Arr size 8 0xbe4680
0 0 0 
Arr size 8 0xbe4690
0 0 1000 
Arr size 8 0xbeef40
0 0 0 
Arr size 8 0xbeef50
0 0 0 
Arr size 8 0xbeef60
0 0 1000

原位構造

位構造 new (地址),其意思為:在某個地址上調用某個構造函數,構造一個相關的對象

如果數據類型T執行深拷貝的函數,將call T類型的拷貝構造函數

https://hedzr.com/c++/variant/in-place-construction-in-cxx/ 參考文章

 Vector(const Vector &a):n(a.n){
        //  data = new T[n];//實現深拷貝， 帶new 就調用n次構造函數
         data =(T *)malloc(sizeof(T) * n); 
        /* for(int i = 0; i < n; i++){
           data[i]=a.data[i];
           } */
        //1 : memcpy 可能是複製類型是複雜類型的對象
        //原位構造 new (地址),其意思為:在某個地址上調用某個構造函數,構造一個相關的對象
        for(int i = 0; i < n; i++){
            //如果數據類型T執行深拷貝的函數,將call T類型的拷貝構造函數 
            new (data + i) T(a.data[i]); //這裡也調了i次                                     
        }
      // memcpy(data,a.data,sizeof(T) * n);
        return ;
    }

返回值優化 (RVO)

對象: 已經經歷了構造過程的數據區 。obj （申請對象數據區）→匹配構造函數 →完成構造（某對象）

-fno-elide-constructors 關閉返回值優化

拷貝構造的現象

按照流程應該是發生了三次構造 ? 為什麼輸出的解構為什麼是同一個地址
按照正常邏輯, 中間的匿名對象應該沒意義的 只是一個中轉的功能
所以 第一步就吧匿名的臨時變數優化掉
第二 ->tmep 拷貝給A對象 ，既然是拷貝他們是一模一樣，加在temp對象所有的操作都會在去往A上
temp 對象其實可以看做A對象的別名,這就是返回值優化的最終版本
最終是 吧temp 當做A對象的引用了

#include<iostream>
#include<queue>
#include<cmath>
#include<vector>
#include<set>
#include<map>
#include<stack>
#include<algorithm>
  
using namespace std;
  
class A{
public:
    A(){
        cout << this <<"  default constructor" << endl;
    }
    A(int x){
        cout << this << "  param cpms" << endl;
    }
    A(const A&a){
        cout << "  copy constructor" << endl;
    }
};
  
A  func(){
    A temp(3);   // 代參數的構造
    cout << " temp " <<  &temp << endl;
    return temp;// 這裡應該是屬於匿名變數拷貝給了 A
}


int main(){
    A a =func(); //匿名對象在拷貝A 
    cout  <<" a :"  << &a <<endl;
     return   0;
}

關閉的優化後
0x7ffc7872633f  param cpms
 temp 0x7ffc7872633f
  copy constructor
  copy constructor
 a :0x7ffc7872635e   
 
 
 
 優化後
 0x7ffef5b875cf  param cpms
 temp 0x7ffef5b875cf
 a :0x7ffef5b875cf

關鍵字

隱形的行為，顯性化 ，將代碼的層面的規則，變成顯示的規則

default

不一樣點 ：如果想要實現拷貝構造必須是初始化列表挨個拷貝, default 關鍵字會挨個執行拷貝方法

如果是預設的構造函數，他是一個東西

class A{
  A() = default;  // 隱性的行為顯性化
  A(const A &) =default;  
  A(const A &) {} //這和上面不是一個東西
};

delete

刪除後，如果想使用，編譯會直接報錯。 

class A{                                                                           |~                   
  A() = default;  // 隱性的行為顯性化                                              |~                   
  //A(const A &) =default;                                                         |~                   
  A(const A &) = delete;                                                           |~                   
                                                                                   |~                   
  // A() {} 這和上面不是一個東西                                                   |~                   
};                                                                                 |~

函數重載

如果一個作用內，函數名稱相同，但是參數列表不同，稱函數重載 （參數類型不同，參數個數不同（記得預設參數的問題））。

強調一下 和返回值沒關係

問題

函數重載 好處？

  1. 有了函數重載，可以吧把一類通過參數區分的功能，命名成一個函數名。（精細化的處理流程）
  2. 通過函數參數的列表對函數進行提示
  3. 對函數進行擴展

code

int func(int x ){
    return 2 * x;
}

double func(double x){ 
    return 2.0 * x;
}

int ABS(int x ){
    return abs(x);
}
double ABS(double x){ 
    return fabs(x);
}
int main(){
    cout << func(1) << endl;
    cout << func(22.0) << endl;
    
    cout <<  ABS(222.56) << endl;
    cout << ABS(-233) << endl ;
  return 0;
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 這13個Python GUI庫，正在學習Python的你必須知道
    Python是一種高級編程語言，它用於通用編程，由Guido van Rossum 在1991年首次發佈。Python 的設計著重於代碼的可讀性。 Python有一個非常大的標準庫，並且有一個動態類型系統，它還具有自動記憶體管理功能，支持多種編程範例。這些包括： ● 面向對象 ● 命令式 ● 函數式 ...
  • 在Eclipse中，移動滑鼠懸停到一些標簽時標簽名會暫時消失？
    剛開始使用eclipse軟體學習Java時，發現它的工具欄的圖標實在是太小了，怎麼解決呢？ 你開始打開瀏覽器，在搜索欄中敲入“eclipse的工具欄的圖標太小怎麼辦？”，瀏覽了很多的方法，然後發現一個帖子上寫的方法很簡單（如下圖）， 按照它的方法操作，發現圖標的大小問題解決了，但是卻出現了一個更大的 ...
  • 結構化併發應用程式-Executor框架的理解與使用
    前言 在我們實際工作過程中,往往會將大的任務劃分成幾個小的子任務,待所有子任務完成之後,再整合出大任務的結果.(例如: 新增直播課的場景),任務的性質通常是多種多樣的,這裡列舉一些任務的常見性質. 從資源使用的角度: CPU密集型 (枚舉素數) I/O密集型 (文件上傳下載) 從執行過程的角度: 依 ...
  • golang中關於死鎖的思考與學習
    1：將兩個列表合併成一個字典 假設我們在 Python 中有兩個列表，我們希望將它們合併為字典形式，其中一個列表的項作為字典的鍵，另一個作為值。這是在用 Python 編寫代碼時經常遇到的一個非常常見的問題 但是為瞭解決這個問題，我們需要考慮幾個限制，比如兩個列表的大小，兩個列表中元素的類型，以及其 ...
  • 玩轉SpringBoot原理：掌握核心技術，成為高級開發者
    本文通過編寫一個自定義starter來學習springboot的底層原理，幫助我們更好的使用springboot集成第三方插件 步驟一：創建項目 步驟二：添加依賴 步驟三：創建自動配置類 步驟四：創建屬性類 步驟五：創建服務類 步驟六：添加自動配置類到Springboot自動配置列表中 步驟七：打包 ...
  • 利用Python實現繪製3D愛心的代碼分享
    環境介紹 python3.8 numpy matplotlib 一、繪製一個三維的愛心 關於這一步，我採用的是大佬博客中的最後一種繪製方法。當然，根據我的代碼習慣，我還是稍做了一點點修改的。 class Guess: def __init__(self, bbox=(-1.5, 1.5), reso ...
  • python爬取全國二手車數據，看看有沒有可以撿漏的！
    絮叨一下 話說，最近從湖北開始汽車價格戰，全國人民都跑到湖北買車去了，搞得人家都出政策限制外地人購買了。 不過12W的C6是真香吶，二十多萬的C6一身毛病，12W的C6毛病在我！ 這波價格戰直接蔓延到全國，全國的二手車商已原地哭暈。 今天我們就用Python來獲取一下全國二手車數據，看看二手車有沒有 ...
  • 使用python爬蟲爬取鏈家濰坊市二手房項目
    使用python爬蟲爬取鏈家濰坊市二手房項目 需求分析 需要將濰坊市各縣市區頁面所展示的二手房信息按要求爬取下來，同時保存到本地。 流程設計 明確目標網站URL（ https://wf.lianjia.com/ ） 確定爬取二手房哪些具體信息（欄位名） python爬蟲關鍵實現：requests庫和 ...
一周排行
    -Advertisement-
    Play Games
  • ASP.NET Core - 選項系統之源碼介紹
    .NET Core 選項系統的主要實現在 Microsoft.Extensions.Options 和 Microsoft.Extensions.Options.ConfigurationExtensions 兩個 Nuget 包。對於一個框架的源碼進行解讀，我們可以從我們常用的框架中的類或方法入手 ...
  • BitMap對象當前正在其他地方使用？加鎖也沒用？
    最近在工作中遇到一個問題,就是我有多個線程會調用bitmap對象，運行的時候報錯，對象當前正在其他地方使用。第一反應肯定是加鎖啊，於是我就在每個用到bitmap的地方都加了鎖，但是運行之後依然報這個錯 測試代碼如下 using System; using System.Drawing; using ...
  • 記一次 .NET 某感測器採集系統 線程爆高分析
    一：背景 1. 講故事 前段時間有位朋友微信找到我，說他的程式使用 hsl 庫之後，採集 plc 時記憶體溢出，讓我幫忙看一下怎麼回事，哈哈，貌似是分析之旅中的第二次和 hsl 打交道，既然找到我，那就上 windbg 說話吧。 二：WinDbg 分析 1. 為什麼會記憶體溢出 簡單觀察程式的提交記憶體之 ...
  • WPF日曆控制項
    在 IIS 上啟用 Websocket 在 Windows Server 2012 或更高版本上啟用對 WebSocket 協議的支持： 備註 使用 IIS Express 時無需執行這些步驟 通過“管理”菜單或“伺服器管理器”中的鏈接使用“添加角色和功能”嚮導。 選擇“基於角色或基於功能的安裝”。 ...
  • C#-垃圾回收機制(GC)
    C#-垃圾回收機制(GC) 什麼是GC 官網中有這麼一句話： The garbage collector is a common language runtime component that controls the allocation and release of managed memory ...
  • 交互觸摸大屏概念整理
    呆了2個大屏行業的公司，對大屏幕有一些瞭解，所以整理下所瞭解的觸摸屏相關概念。方便自己以及進入這個行業的小伙伴們，能有個系統、快速的認知。 觸摸屏詳細的知識點，網上其實都有。整理資料過程中，我也瞭解了更多的觸摸屏知識，像聲波屏、光學屏之類的之前就沒接觸。下麵分不同的模塊，給大家介紹 交互觸摸屏類型 ...
  • APS系統設計經驗分享(時間推導 - 2023.03)
    近段時間忙於各種項目和對【易排平臺】的優化，沒顧得上分享APS相關的小技巧，回頭看看小公眾號的關註人數早已達1500+，在此爭取時間寫一下這段時間在項目上及平臺優化過程中遇到的一些小技巧，以感謝諸位的關註。過去數月的解決的問題中，涉及最多的是規劃模型中，實現各種時間維度的功能，目前在平臺上也稍有成果 ...
  • Linux 伺服器大量的 log 日誌，如何正確看日誌快速定位錯誤？你必須學會！
    針對大量log日誌快速定位錯誤地方 動態查看日誌 tail -f catalina.ou 從頭打開日誌文件 cat catalina.ou 可以使用 >nanjiangtest.txt 輸出某個新日誌去查看 [[email protected] logs]# cat -n catalina.out |grep 7 ...
  • RocketMQ 學習
    前言 RocketMQ是阿裡巴巴旗下一款開源的MQ框架，經歷過雙十一考驗、Java編程語言實現，有非常好完整生態系統。RocketMQ作為一款純java、分散式、隊列模型的開源消息中間件，支持事務消息、順序消息、批量消息、定時消息、消息回溯等 本篇文章第一部分屬於一些核心概念和工作流程的講解；第二部 ...
  • python中類成員修飾符
    在java，c#類的成員修飾符包括，公有、私有、程式集可用的、受保護的。 對於python來說，只有兩個成員修飾符：公有成員，私有成員 成員修飾符是來修飾誰呢？當然是修飾成員了。那麼python類的成員包括什麼呢？ python成員： 欄位，方法，屬性 每個類成員的修飾符有兩種: 公有成員:內部外部 ...
所有分類