C++98/11/17表達式類別

来源:https://www.cnblogs.com/jerry-fuyi/archive/2020/05/23/12927532.html
-Advertisement-
Play Games

從C++98到C++17，表達式類別與時俱進地改變著。引用綁定、auto、decltype、拷貝省略等功能與表達式類別息息相關。 ...


目標

以下代碼能否編譯通過，能否按照期望運行？（點擊展開） 
#include <utility>
#include <type_traits>

namespace cpp98
{

struct A { };
A func() { return A(); }

int main()
{
    int i = 1;
    i = 2;
    // 3 = 4;
    const int j = 5;
    // j = 6;
    i = j;
    func() = A();
    return 0;
}

}

namespace cpp11
{

#define is_lvalue(x)  std::is_lvalue_reference<decltype((x))>::value
#define is_prvalue(x) !std::is_reference<decltype((x))>::value
#define is_xvalue(x)  std::is_rvalue_reference<decltype((x))>::value
#define is_glvalue(x) (is_lvalue(x) || is_xvalue(x))
#define is_rvalue(x)  (is_xvalue(x) || is_prvalue(x))

void func();
int non_reference();
int&& rvalue_reference();
std::pair<int, int> make();

struct Test
{
    int field;
    void member_function()
    {
        static_assert(is_lvalue(field), "");
        static_assert(is_prvalue(this), "");
    }
    enum Enum
    {
        ENUMERATOR,
    };
};

int main()
{
    int i;
    int&& j = std::move(i);
    Test test;

    static_assert(is_lvalue(i), "");
    static_assert(is_lvalue(j), "");
    static_assert(std::is_rvalue_reference<decltype(j)>::value, "");
    static_assert(is_lvalue(func), "");
    static_assert(is_lvalue(test.field), "");
    static_assert(is_lvalue("hello"), "");

    static_assert(is_prvalue(2), "");
    static_assert(is_prvalue(non_reference()), "");
    static_assert(is_prvalue(Test{3}), "");
    static_assert(is_prvalue(test.ENUMERATOR), "");

    static_assert(is_xvalue(rvalue_reference()), "");
    static_assert(is_xvalue(make().first), "");

    return 0;
}

}

namespace reference
{

int&& rvalue_reference()
{
    int local = 1;
    return std::move(local);
}

const int& const_lvalue_reference(const int& arg)
{
    return arg;
}

int main()
{
    auto&& i = rvalue_reference();        // dangling reference
    auto&& j = const_lvalue_reference(2); // dangling reference
    int k = 3;
    auto&& l = const_lvalue_reference(k);
    return 0;
}

}

namespace auto_decl
{

int non_reference() { return 1; }
int& lvalue_reference() { static int i; return i; }
const int& const_lvalue_reference() { return lvalue_reference(); }
int&& rvalue_reference() { static int i; return std::move(i); }

int main()
{
    auto [s1, s2] = std::pair(2, 3);
    auto&& t1 = s1;
    static_assert(!std::is_reference<decltype(s1)>::value);
    static_assert(std::is_lvalue_reference<decltype(t1)>::value);

    int i1 = 4;
    auto i2 = i1;
    decltype(auto) i3 = i1;
    decltype(auto) i4{i1};
    decltype(auto) i5 = (i1);
    static_assert(!std::is_reference<decltype(i2)>::value, "");
    static_assert(!std::is_reference<decltype(i3)>::value, "");
    static_assert(!std::is_reference<decltype(i4)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(i5)>::value, "");

    auto n1 = non_reference();
    decltype(auto) n2 = non_reference();
    auto&& n3 = non_reference();
    static_assert(!std::is_reference<decltype(n1)>::value, "");
    static_assert(!std::is_reference<decltype(n2)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(n3)>::value, "");

    auto l1 = lvalue_reference();
    decltype(auto) l2 = lvalue_reference();
    auto&& l3 = lvalue_reference();
    static_assert(!std::is_reference<decltype(l1)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(l2)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(l3)>::value, "");

    auto c1 = const_lvalue_reference();
    decltype(auto) c2 = const_lvalue_reference();
    auto&& c3 = const_lvalue_reference();
    static_assert(!std::is_reference<decltype(c1)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(c2)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(c3)>::value, "");

    auto r1 = rvalue_reference();
    decltype(auto) r2 = rvalue_reference();
    auto&& r3 = rvalue_reference();
    static_assert(!std::is_reference<decltype(r1)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(r2)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(r3)>::value, "");

    return 0;
}

}

namespace cpp17
{

class NonMoveable
{
public:
    int i = 1;
    NonMoveable(int i) : i(i) { }
    NonMoveable(NonMoveable&&) = delete;
};

NonMoveable make(int i)
{
    return NonMoveable{i};
}

void take(NonMoveable nm)
{
    return static_cast<void>(nm);
}

int main()
{
    auto nm = make(2);
    auto nm2 = NonMoveable{make(3)};
    // take(nm);
    take(make(4));
    take(NonMoveable{make(5)});
    return 0;
}

}

int main()
{
    cpp98::main();
    cpp11::main();
    reference::main();
    auto_decl::main();
    cpp17::main();
}

C++98表達式類別

每個C++表達式都有一個類型：42的類型為int，int i;則(i)的類型為int&。這些類型落入若幹類別中。在C++98/03中，每個表達式都是左值或右值。

左值（lvalue）是指向真實儲存在記憶體或寄存器中的值的表達式。“l”指的是“left-hand side”，因為在C中只有lvalue才能寫在賦值運算符的左邊。相對地，右值（rvalue，“r”指的是“right-hand side”）只能出現在賦值運算符的右邊。

有一些例外，如const int i;，i雖然是左值但不能出現在賦值運算符的左邊。到了C++，類類型的rvalue卻可以出現在賦值運算符的左邊，事實上這裡的賦值是對賦值運算符函數的調用，與基本類型的賦值是不同的。

lvalue可以理解為可取地址的值，變數、對指針解引用、對返回類型為引用類型的函數的調用等，都是lvalue。臨時對象都是rvalue，包括字面量和返回類型為非引用類型的函數調用等。字元串字面量是個例外，它屬於不可修改的左值。

賦值運算符左邊需要一個lvalue，右邊需要一個rvalue，如果給它一個lvalue，該lvalue會被隱式轉換成rvalue。這個過程是理所當然的。

動機

C++11引入了右值引用和移動語義。函數返回的右值引用，顧名思義，應該表現得和右值一樣，但是這會破壞很多既有的規則：

  • rvalue是匿名的，不一定有存儲空間，但右值引用指向記憶體中的具體對象，該對象還要被維護著；

  • rvalue的類型是確定的，必須是完全類型，靜態類型與動態類型相同，而右值引用可以是不完全類型，也可以支持多態；

  • 非類類型的rvalue沒有cv修飾（const和volatile），但右值引用可以有，而且修飾符必須保留。

這給傳統的lvalue/rvalue二分法帶來了挑戰，C++委員會面臨選擇：

  • 維持右值引用是rvalue，添加一些特殊規則；

  • 把右值引用歸為lvalue，添加一些特殊規則；

  • 細化表達式類別。

上述問題只是冰山一角；歷史選擇了第三種方案。

C++11表達式類別

C++11提出了表達式類別（value category）的概念。雖然名叫“value category”，但類別劃分的是表達式而不是值，所以我從標題開始就把它譯為“表達式類別”。C++標准定義表達式為：

An expression is a sequence of operators and operands that specifies a computation. An expression can result in a value and can cause side effects.

每個表達式都是三種類別之一：左值（lvalue）、消亡值（xvalue）和純右值（prvalue），稱為主類別。還有兩種混合類別：lvalue和xvalue統稱範左值（glvalue），xvalue和prvalue統稱右值（rvalue）。

#define is_glvalue(x) (is_lvalue(x) || is_xvalue(x))
#define is_rvalue(x)  (is_xvalue(x) || is_prvalue(x))

C++11對這些類別的定義如下：

  • lvalue指定一個函數或一個對象；

  • xvalue（eXpiring vavlue）也指向對象，通常接近其生命周期的終點；一些涉及右值引用的表達式的結果是xvalue；

  • gvalue（generalized lvalue）是一個lvalue或xvalue；

  • rvalue是xvalue、臨時對象或它們的子對象，或者沒有關聯對象的值；

  • prvalue（pure rvalue）是不是xvalue的rvalue。

這種定義不是很清晰。具體來講，lvalue包括：（點擊展開）

  • 變數、函數、數據成員的名字，包括右值引用類型的變數也是lvalue；

    int i;
int&& j = std::move(i);
static_assert(is_lvalue(j), "");
static_assert(std::is_rvalue_reference<decltype(j)>::value, "");

  • 函數調用或重載運算符表達式，其返回類型為左值引用類型，或函數的右值引用類型；

  • 內置賦值、複合賦值、前置自增、前置自減運算符表達式；

  • 內置數組下標表達式a[n]和p[n]（a為數組類型，p為指針類型），a是一個數組lvalue；

  • a.m，除非m是枚舉成員，或非靜態成員函數，或a是rvalue且m是非引用類型的非靜態數據成員；

  • p->m，除非m是枚舉成員，或非靜態成員函數；

  • a.*mp，a是一個lvalue，mp是數據成員指針；

  • p->*mp，mp是數據成員指針；

  • 逗號表達式，第二個運算數是lvalue；

  • 條件運算符a ? b : c，這裡有非常複雜的規則，舉其中一例，當b和c是相同類型的lvalue時；

  • 字元串字面量；

  • 顯式轉換為左值引用類型或函數的右值引用類型。

lvalue的性質：

  • 與glvalue相同；

  • 內置取地址運算符可以作用於lvalue；

  • 可修改的lvalue可以出現在內置賦值運算符的左邊；

  • 可以用來初始化一個左值引用。

prvalue包括：

  • 除字元串以外的字面量；

  • 函數調用或重載運算符表達式，其返回類型為非引用類型；

  • 內置算術運算、邏輯運算、比較運算、取地址運算符表達式；

  • a.m或p->m，m是枚舉成員或非靜態成員函數（見下）；

  • a.*mp或p->*mp，mp是成員函數指針；

  • 逗號表達式，第二個運算數是rvalue；

  • 條件運算符a ? b : c的部分情況，如b和c是相同類型的prvalue；

  • 顯式轉換為非引用類型；

  • this指針；

  • 枚舉成員；

  • 非類型模板參數，除非它是左值引用類型；

  • lambda表達式。

prvalue的性質：

  • 與rvalue相同；

  • 不能是多態的；

  • 非類類型且非數組的prvalue沒有cv修飾符，即使寫了也沒有；

  • 必須是完全類型；

  • 不能是抽象類型或其數組。

xvalue包括：

  • 函數調用或重載運算符表達式，其返回類型為右值引用類型；

  • 內置數組下標表達式a[n]，a是一個數組rvalue；

  • a.m，a是rvalue且m是非引用類型的非靜態數據成員；

  • a.*mp，a是一個rvalue，mp是數據成員指針；

  • 條件運算符a ? b : c的部分情況，如b和c是相同類型的xvalue。

xvalue的性質；

  • 與rvalue相同；

  • 與glvalue相同。

glvalue的性質：

  • 可以隱式轉換為prvalue；

  • 可以是多態的；

  • 可以是不完全類型。

rvalue的性質：

  • 內置取地址運算符不能作用於rvalue；

  • 不能出現在內置賦值或複合賦值運算符的左邊；

  • 可以綁定給const左值引用（見下）；

  • 可以用來初始化右值引用（見下）；

  • 如果一個函數有右值引用參數和const左值引用參數兩個重載，傳入一個rvalue時，右值引用的那個重載被調用。

還有一些特殊的分類：

  • 對於非靜態成員函數mf及其指針pmf，a.mf、p->mf、a.*pmf和p->*pmf都被歸類為prvalue，但它們不是常規的prvalue，而是pending（即將發生的） member function call，只能用於函數調用；

  • 返回void的函數調用、向void的類型裝換和throw語句都是void表達式，不能用於初始化引用或函數參數；

  • C++中最小的定址單位是位元組，因此位域不能綁定到非const左值引用上；const左值引用和右值引用可以綁定位域，它們指向的是位域的一個拷貝。

終於把5個類別介紹完了。表達式可以分為lvalue、xvalue和prvalue三類，lvalue和prvalue與C++98中的lvalue和rvalue類似，而xvalue則完全是為右值引用而生，兼有glvalue與rvalue的性質。除了這種三分類法外，表達式還可以分為lvalue和rvalue兩類，它們之間的主要差別在於是否可以取地址；還可以分為glvalue和prvalue兩類，它們之間的主要差別在於是否存在實體，glvalue有實體，因而可以修改原對象，xvalue常被壓榨剩餘價值。

引用綁定

我們稍微岔開一會，來看兩個與表達式分類相關的特性。

引用綁定有以下類型：

  • 左值引用綁定lvalue，cv修飾符只能多不能少；

  • 右值引用可以綁定rvalue，我們通常不給右值引用加cv修飾符；

  • const左值引用可以綁定rvalue。

左值引用綁定lvalue天經地義，沒什麼需要關照的。但rvalue都是臨時對象，綁定給引用就意味著要繼續用它，它的生命周期會受到影響。通常，rvalue的生命周期會延長到綁定引用的聲明周期，但有以下例外：

  • 由return語句返回的臨時對象在return語句結束後即銷毀，這樣的函數總是會返回一個空懸引用（dangling reference）；

  • 綁定到初始化列表中的引用的臨時對象的生命周期只延長到構造函數結束——這是個缺陷，在C++14中被修複；

  • 綁定到函數參數的臨時對象的生命周期延長到函數調用所在表達式結束，把該參數作為引用返回會得到空懸引用；

  • 綁定到new表達式中的引用的臨時對象的生命周期只延長到包含new的表達式的結束，不會跟著那個對象。

簡而言之，臨時變數的生命周期只能延長一次。

#include <utility>

int&& rvalue_reference()
{
    int local = 1;
    return std::move(local);
}

const int& const_lvalue_reference(const int& arg)
{
    return arg;
}

int main()
{
    auto&& i = rvalue_reference();        // dangling reference
    auto&& j = const_lvalue_reference(2); // dangling reference
    int k = 3;
    auto&& l = const_lvalue_reference(k);
}

rvalue_reference返回一個指向局部變數的引用，因此i是空懸引用；2綁定到const_lvalue_reference的參數arg上，函數返回後延長的生命周期達到終點，因此j也是懸空引用；k在傳參的過程中根本沒有臨時對象創建出來，所以l不是空懸引用，它是指向k的const左值引用。

auto與decltype

從C++11開始，auto關鍵字用於自動推導類型，用的是模板參數推導的規則：如果是拷貝列表初始化，則對應模板參數為std::initializer_list<T>，否則把auto替換為T。至於詳細的模板參數推導規則，要介紹的話未免喧賓奪主了。

還好，這不是我們的重點。在引出重點之前，我們還得先看decltype。

decltype用於聲明一個類型（"declare type"），有兩種語法：

  • decltype(entity)；

  • decltype(expression)。

第一種，decltype的參數是沒有括弧包裹的標識符或類成員，則decltype產生該實體的類型；如果是結構化綁定，則產生被引類型。

第二種，decltype的參數是不能匹配第一種的任何表達式，其類型為T，則根據其表達式類別討論：

  • 如果是xvalue，產生T&&——#define is_xvalue(x) std::is_rvalue_reference<decltype((x))>::value；

  • 如果是lvalue，產生T&——#define is_lvalue(x) std::is_lvalue_reference<decltype((x))>::value；

  • 如果是prvalue，產生T——#define is_prvalue(x) !std::is_reference<decltype((x))>::value。

因此，decltype(x)和decltype((x))產生的類型通常是不同的。

對於不帶引用修飾的auto，初始化器的表達式類別會被抹去，為此C++14引入了新語法decltype(auto)，產生的類型為decltype(expr)，其中expr為初始化器。對於局部變數，等號右邊加上一對圓括弧，可以保留表達式類別。

#include <utility>
#include <type_traits>

int non_reference() { return 1; }
int& lvalue_reference() { static int i; return i; }
const int& const_lvalue_reference() { return lvalue_reference(); }
int&& rvalue_reference() { static int i; return std::move(i); }

int main()
{
    auto [s1, s2] = std::pair(2, 3);
    auto&& t1 = s1;
    static_assert(!std::is_reference<decltype(s1)>::value);
    static_assert(std::is_lvalue_reference<decltype(t1)>::value);

    int i1 = 4;
    auto i2 = i1;
    decltype(auto) i3 = i1;
    decltype(auto) i4{i1};
    decltype(auto) i5 = (i1);
    static_assert(!std::is_reference<decltype(i2)>::value);
    static_assert(!std::is_reference<decltype(i3)>::value);
    static_assert(!std::is_reference<decltype(i4)>::value);
    static_assert(std::is_lvalue_reference<decltype(i5)>::value);

    auto n1 = non_reference();
    decltype(auto) n2 = non_reference();
    auto&& n3 = non_reference();
    static_assert(!std::is_reference<decltype(n1)>::value, "");
    static_assert(!std::is_reference<decltype(n2)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(n3)>::value, "");

    auto l1 = lvalue_reference();
    decltype(auto) l2 = lvalue_reference();
    auto&& l3 = lvalue_reference();
    static_assert(!std::is_reference<decltype(l1)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(l2)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(l3)>::value, "");

    auto c1 = const_lvalue_reference();
    decltype(auto) c2 = const_lvalue_reference();
    auto&& c3 = const_lvalue_reference();
    static_assert(!std::is_reference<decltype(c1)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(c2)>::value, "");
    static_assert(std::is_lvalue_reference<decltype(c3)>::value, "");

    auto r1 = rvalue_reference();
    decltype(auto) r2 = rvalue_reference();
    auto&& r3 = rvalue_reference();
    static_assert(!std::is_reference<decltype(r1)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(r2)>::value, "");
    static_assert(std::is_rvalue_reference<decltype(r3)>::value, "");
}

用auto定義的變數都是int類型，無論函數的返回類型的引用和const修飾；用decltype(auto)定義的變數的類型與函數返回類型相同；auto&&是轉發引用，n3類型為int&&，其餘與decltype(auto)相同。

C++17表達式類別

眾所周知，編譯器常會執行NRVO（named return value optimization），減少一次對函數返回值的移動或拷貝。不過，這屬於C++標準說編譯器可以做的行為，卻沒有保證編譯器會這麼做，因此客戶不能對此作出假設，從而需要提供一個拷貝或移動構造函數，儘管它們可能不會被調用。然而，並不是所有情況下都能提供移動構造函數，即使能移動構造函數也未必只是一個指針的交換。總之，我們明知移動構造函數不會被調用卻還要硬著頭皮提供一個，這樣做非常形式主義。

所以，C++17規定了拷貝省略，確保在以下情況下，即使拷貝或移動構造函數有可觀察的效果，它們也不會被調用，原本要拷貝或移動的對象直接在目標位置構造：

  • 在return表達式中，運算數是忽略cv修飾符以後的返回類型的prvalue；

  • 在初始化中，初始化器是與變數相同類型的prvalue。

值得一提的是，這類行為在C++17中不能算是一種優化，因為不存在用來拷貝或移動的臨時對象。事實上，C++17重新定義了表達式類別：

  • glvalue的求值能確定對象、位域、函數的身份；

  • prvalue的求值初始化對象或位域，或計算運算數的值，由上下文決定；

  • xvalue是表示一個對象或位域的資源能被重用的glvalue；

  • lvalue是不是xvalue的glvalue；

  • rvalue是prvalue或xvalue。

這個定義在功能上與C++11中的相同，但是更清晰地指出了glvalue和prvalue的區別——glvalue產生地址，prvalue執行初始化。

prvalue初始化的對象由上下文決定：在拷貝省略的情形下，prvalue不曾有關聯的對象；其他情形下，prvalue將產生一個臨時對象，這個過程稱為臨時實體化（temporary materialization）。

臨時實體化把一個完全類型的prvalue轉換成xvalue，在以下情形中發生：

  • 把引用綁定到prvalue上；

  • 類prvalue被獲取成員；

  • 數組prvalue被轉換為指針或下標取元素；

  • prvalue出現在大括弧初始化列表中，用於初始化一個std::initializer_list<T>；

  • 被使用typeid或sizeof運算符；

  • 在語句expr;中或被轉換成void，即該表達式的值被丟棄。

或者可以理解為，所有非拷貝省略的場合中的prvalue都會被臨時實體化。

class NonMoveable
{
public:
    int i = 1;
    NonMoveable(int i) : i(i) { }
    NonMoveable(NonMoveable&&) = delete;
};

NonMoveable make(int i)
{
    return NonMoveable{i};
}

void take(NonMoveable nm)
{
    return static_cast<void>(nm);
}

int main()
{
    auto nm = make(2);
    auto nm2 = NonMoveable{make(3)};
    // take(nm);
    take(make(4));
    take(NonMoveable{make(5)});
}

NonMoveable的移動構造函數被聲明為delete，於是拷貝構造函數也被隱式delete。在auto nm = make(2);中，NonMoveable{i}為prvalue，根據拷貝省略的第一條規則，它直接構造為返回值；返回值是NonMoveable的prvalue，與nm類型相同，根據第二條規則，這個prvalue直接在nm的位置上構造；兩部分結合，該聲明式相當於NonMoveable nm{2};。

在MSVC中，這段代碼不能通過編譯，這是編譯器未能嚴格遵守C++標準的緣故。然而，如果在NonMoveable的移動構造函數中添加輸出語句，程式運行起來也沒有任何輸出，即使在Debug模式下、即使用C++11標準編譯都如此。這也側面反映出拷貝省略的意義。

總結

C++11規定每個表達式都屬於lvalue、xvalue和prvalue三個類別之一，表達式另可分為lvalue和rvalue，或glvalue和prvalue。返回右值引用的函數調用是xvalue，右值引用類型的變數是lvalue。

const左值引用和右值引用可以綁定臨時對象，但是臨時對象的聲明周期只能延長一次，返回一個指向局部變數的右值引用也會導致空懸引用。

標識符加上一對圓括弧成為表達式，decltype用於表達式可以根據其類別產生相應的類型，用decltype(auto)聲明變數可以保留表達式類別。

C++17中prvalue是否有關聯對象由上下文決定，拷貝省略規定了特定情況下對象不經拷貝或移動直接構造，NRVO成為強制性標準，使不能被移動的對象在語義上可以值傳遞。

參考


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

-Advertisement-
Play Games
更多相關文章
  • 還在羡慕程式員工資高嗎？看完這篇前端學習計劃，你也可以拿高薪
    什麼是前端？ 前端即網站前臺部分，也叫前端開發，運行在PC端，移動端等瀏覽器上展現給用戶瀏覽的網頁。隨著互聯網的發展，HTML5，CSS3，前端框架的應用，跨平臺響應式網頁設計能夠適應各種屏幕解析度，完美的動效設計，給用戶帶來極高的用戶體驗。 （核心技術：HTML、CSS、JavaScript） 核 ...
  • 從零開始搭建一個PaaS平臺 - 我們要做什麼
    前言 從最開始的小公司做小網站，到現在進入現在的公司做項目，發現小公司里很多很多工作都是重覆的勞動（增刪改查），不過想想也是，業務軟體最基礎的東西不就是增刪改查嗎。 但是很多時候，這種業務邏輯其實沒有必要挨個重寫。總不能說你的增刪改查比我的高級很多。很大程度上，複雜的問題只是數據太多了怎麼優化。 簡 ...
  • 軟體設計模式學習（十九）解釋器模式
    解釋器是一種不常使用的設計模式，它用於描述如何構成一個簡單的語言解釋器，主要應用於使用面向對象語言開發的編譯器和解釋器設計。當我們需要開發一個新的語言時，可以考慮使用解釋器模式 模式動機 如果在系統中某一特定類型的問題發生的頻率很高，此時可以考慮將這些問題的實例表述為一個語言中的句子。再構建一個解釋 ...
  • numpy學習之思維導圖
    使用請註明出處 整理不易 ...
  • APM 上報信息分析與應用
    在入正題之前我們再回顧下它的架構圖： 本文章主要分析AMP各索引的作用，與及結合1.7環境上已接入的服務數據對比後，對索引中的主要欄位進行解析。文章分為四個小章節。 1、索引類型 apm索引分為四種類型： 系統指標索引(System status metrics)，索引名稱格式：apm-versio ...
  • Python--集合
    集合（set）是一個無序的不重覆元素序列。 可以使用大括弧 { } 或者 set() 函數創建集合，註意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。 創建格式：list_1 = {value01,value02,...} 或者 set(value) 集合作 ...
  • Python--文件操作（操作文件）
    文件的操作包含：讀、寫、修改 文件的多種操作： 1 # 讀取文件的所有內容 2 data = open("yesteday.txt", encoding="utf-8") .read() 3 print(data) 4 5 ''' f:文件句柄（包含這個文件的文件名，字元集，大小，在硬碟中的起始位置 ...
  • JAVA設計模式之原型模式（prototype）
    原型模式： 原型模式又叫克隆模式 Java自帶克隆模式 實現克隆模式必須實現Cloneable 介面，如果不實現會發生java.lang.CloneNotSupportedException異常 當某個類的屬性已經設定好需要創建很多相同屬性值的對象的時候使用clone模式非常方便 使用clone模式 ...
一周排行
    -Advertisement-
    Play Games
  • GoF之工廠模式
    GoF之工廠模式 @目錄GoF之工廠模式每博一文案1. 簡單說明“23種設計模式”1.2 介紹工廠模式的三種形態1.3 簡單工廠模式（靜態工廠模式）1.3.1 簡單工廠模式的優缺點:1.4 工廠方法模式1.4.1 工廠方法模式的優缺點:1.5 抽象工廠模式1.6 抽象工廠模式的優缺點：2. 總結:3 ...
  • dotnet C# 簡單的追加文件夾到 ZipArchive 壓縮文件的方法
    新改進提供的Taurus Rpc 功能，可以簡化微服務間的調用，同時可以不用再手動輸出模塊名稱，或調用路徑，包括負載均衡，這一切，由框架實現並提供了。新的Taurus Rpc 功能，將使得服務間的調用，更加輕鬆、簡約、高效。 ...
  • Elasticsearch 系列（六）- ES數據同步和ES集群
    本章將和大家分享ES的數據同步方案和ES集群相關知識。廢話不多說，下麵我們直接進入主題。 一、ES數據同步 1、數據同步問題 Elasticsearch中的酒店數據來自於mysql資料庫，因此mysql數據發生改變時，Elasticsearch也必須跟著改變，這個就是Elasticsearch與my ...
  • 自動化測試數據生成：Asp.Net Core單元測試利器AutoFixture詳解
    引言 在我們之前的文章中介紹過使用Bogus生成模擬測試數據，今天來講解一下功能更加強大自動生成測試數據的工具的庫"AutoFixture"。 什麼是AutoFixture? AutoFixture 是一個針對 .NET 的開源庫，旨在最大程度地減少單元測試中的“安排（Arrange）”階段，以提高 ...
  • .NET Emit 入門教程：第七部分：實戰項目1：將 DbDataReader 轉實體
    經過前面幾個部分學習，相信學過的同學已經能夠掌握 .NET Emit 這種中間語言，並能使得它來編寫一些應用，以提高程式的性能。隨著 IL 指令篇的結束，本系列也已經接近尾聲，在這接近結束的最後，會提供幾個可供直接使用的示例，以供大伙分析或使用在項目中。 ...
  • Windows下綁定線程到指定的CPU核心
    當從不同來源導入Excel數據時，可能存在重覆的記錄。為了確保數據的準確性，通常需要刪除這些重覆的行。手動查找並刪除可能會非常耗費時間，而通過編程腳本則可以實現在短時間內處理大量數據。本文將提供一個使用C# 快速查找並刪除Excel重覆項的免費解決方案。 以下是實現步驟： 1. 首先安裝免費.NET ...
  • mORMot 1.18 第07章 簡單的讀寫操作
    C++ 異常處理 C++ 異常處理機制允許程式在運行時處理錯誤或意外情況。它提供了捕獲和處理錯誤的一種結構化方式，使程式更加健壯和可靠。 異常處理的基本概念： 異常: 程式在運行時發生的錯誤或意外情況。 拋出異常: 使用 throw 關鍵字將異常傳遞給調用堆棧。 捕獲異常: 使用 try-catch ...
  • mORMot 1.18 第06章 概念
    優秀且經驗豐富的Java開發人員的特征之一是對API的廣泛瞭解，包括JDK和第三方庫。 我花了很多時間來學習API，尤其是在閱讀了Effective Java 3rd Edition之後 ，Joshua Bloch建議在Java 3rd Edition中使用現有的API進行開發，而不是為常見的東西編 ...
  • php 開發規範
    框架 · 使用laravel框架，原因：tp的框架路由和orm沒有laravel好用 · 使用強制路由，方便介面多時，分多版本，分文件夾等操作 介面 · 介面開發註意欄位類型，欄位是int，查詢成功失敗都要返回int（對接java等強類型語言方便） · 查詢介面用GET、其他用POST 代碼 · 所 ...
  • 2024 年 4 月 28 日 周日 晴 熱（1253 字）
    正文 下午找企業的人去鎮上做貸後。 車上聽同事跟那個司機對罵，火星子都快出來了。司機跟那同事更熟一些，連我在內一共就三個人，同事那一手指桑罵槐給我都聽愣了。司機也是老社會人了，馬上聽出來了，為那個無辜的企業經辦人辯護，實際上是為自己辯護。 “這個事情你不能怪企業。”“但他們總不能讓銀行的人全權負責， ...
所有分類