cpp msic

cpp misc

std::set iterate方法

// Set of strings
std::set<std::string> setOfStr = {
                            "jjj",
                            "khj",
                            "bca",
                            "aaa",
                            "ddd" };

// Creating a iterator pointing to start of set
std::set<std::string>::iterator it = setOfStr.begin();
// Iterate till the end of set
while (it != setOfStr.end())
{
    // Print the element
    std::cout << (*it) << " , ";
    //Increment the iterator
    it++;
}

from: https://thispointer.com/different-ways-to-iterate-over-a-set-in-c/

std::vector iterate方法

    vector<int>obj;
     
    for(int i=0;i<10;i++)
    {
        obj.push_back(i);
        cout<<obj[i]<<",";    
    }
    cout << endl << "vector size is :" << obj.size() << endl;

    //数组循环遍历
    for(int i=0;i<obj.size();i++)
    {
        cout<<obj[i]<<",";
    }

更多iterate方法见如下link：

https://www.jb51.net/article/218197.htm

std::unique_ptr

std::unique_ptr是具有以下特性的智能指针：

通过指针保留了唯一的对象的所有权，并且
unique_ptr离开作用域时，会析构指向的对象。

如果一个由unique_ptr指向的对象里也有unique_ptr指针，则也会将它指向的对象deconstruct，如下面例子实际执行结果：

// Example program
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <utility>

class TestClass0 {
public:
    uint8_t a;
    ~TestClass0() {
        std::cout << "deconstruct TestClass0.\n";
    }
};

class TestClass1 {
public:
    TestClass1() : ptr(nullptr) {}
    
    TestClass1(TestClass1 && tc) : ptr(std::move(tc.ptr)) {}
    std::unique_ptr<TestClass0> ptr;
    
    ~TestClass1() {
        std::cout << "deconstruct TestClass1.\n";
    }
};

class TestClass2 {
public:
    std::vector<TestClass1> v;
    ~TestClass2() {
      std::cout << "deconstruct TestClass2.\n";
    }
};

int main()
{
  std::unique_ptr<TestClass2> mptr(new TestClass2());
  TestClass1 tc = TestClass1();
  tc.ptr.reset(new TestClass0());
  mptr->v.push_back(std::move(tc));
  
  std::cout << "unique ptr test.\n";
}

执行结果

unique ptr test.
deconstruct TestClass1. //local var tc in main()
deconstruct TestClass2. 
deconstruct TestClass1. //TestClass1 object in vector TestClass2.v
deconstruct TestClass0.

std::unique_ptr<type>与普通指针

如果是unique_ptr，则在生存期结束时会将它指向的对象free；而如果是普通指针（比如通过new来创建的），则需要用delete显式free指针指向的对象，如下面示例代码，如果没有delete指针，则这个对象将没有被free（内存泄露？）

// Example program
#include <iostream>

class TestClass {
public:
    TestClass() {
        std::cout << "TestClass construct.\n";    
    }
    ~TestClass() {
        std::cout << "TestClass deconstruct.\n";    
    }
};

int main()
{
    TestClass *tc = new TestClass();
    std::cout << "object free test.\n";
    delete tc;
    return 0;
}

执行结果：

TestClass construct.
object free test.
TestClass deconstruct.

左值引用&右值引用

左值引用：

int num = 10;
int &a = num;

右值引用：

int num = 10;
int &&a = 10;  //用右值进行引用的初始化
a = 100; //改变右值引用的值

这两种引用都必须在声明引用时进行引用的初始化

创建对象的方式

分为两类，动态分配和编译器自动分配

// Example program
#include <iostream>

class TestClass {
public:
    TestClass() {
        std::cout << "TestClass construct.\n";   
    }
    TestClass(int a)
    {
        std::cout << "TestClass(int) construct.\n";
        num = a;
    }
    ~TestClass() {
        std::cout << "TestClass deconstruct.\n";    
    }
private:
    int num;
};

int main()
{
    TestClass tc0; //empty arg constructor, stack
    TestClass tc1(10); //int arg constructor, stack
    TestClass tc2 = TestClass(); //empty arg constructor, call constructor explicitly, stack
    TestClass *tc3 = new TestClass(); //empty arg constructor, dynamicly alloc on heap
　　 //TestClass *tc4 = new TestClass(11); //dynamicly alloc on heap
    std::cout << "object creation.\n";
    delete tc3; //free on heap 
    
    return 0;
}