hsy12342611

C/C++基本功 - 常见笔试题

俗话说的好，根基不稳，地动山摇，作为一名C/C++开发人员，基本功的扎实程度决定了职业高度，本篇将C/C++常见笔试题进行整理。

1.STL

1.1 vector中push_back和emplace_back的区别

1.2 vector清除内存

2.排序

2.1 冒泡排序

2.2 快速排序

2.3 堆排序

3.内存

3.1 实现memset函数

4.链表

2.1 冒泡排序

2.2 逆序

2.2 合并

（1）修改原始链表的合并

（2）不修改原始链表的合并

5.缓存

5.1 最近最少使用（LRU）

6.字符串

6.1 点分ipv4地址格式化处理

6.2 字符串拆分

6.3 查找最长重复子串

7.IO流

7.1 字符串和文件IO流

8.VC++

8.1 Mutex和临界区

1.STL

1.1 vector中push_back和emplace_back的区别

emplace_back() 函数是 C++11 新增加的，其功能和push_back()相同, emplace_back可以直接通过参数构建容器元素，省去了一次拷贝构造的调

#include
#include 
#include 

using namespace std;

// emplace_back() 函数是 C++11 新增加的，其功能和 push_back()相同, emplace_back可以直接通过参数构建
//容器元素，省去了一次拷贝构造的调
class ItemData
{
public:
    // 无参数构造函数
    ItemData() : m_iData(0), m_strData("")
    { 
        std::cout << "call ItemData() " << this << std::endl;
    }

    //带参数构造函数
    ItemData(int id, std::string strData) : m_iData(id), m_strData(strData)
    { 
        std::cout << "call ItemData(int id, std::string strData) " << this << std::endl;
    }
    //拷贝构造
    ItemData(const ItemData &t) : m_iData(t.m_iData), m_strData(t.m_strData)
    {  
        std::cout << "call ItemData(const ItemData &t) " << this << std::endl;
    }
    //移动构造
    ItemData(const ItemData &&t)
    {
        m_iData = std::move(t.m_iData);
        m_strData = std::move(t.m_strData);
        std::cout << "call ItemData(const ItemData &&t) " << this << std::endl;
    }
    //析构
    ~ItemData()
    {
        std::cout << "call ~ItemData() " << this << std::endl;
    }

private:
    int         m_iData; 
    std::string m_strData;
};

void test1() {
    std::cout << "----------------------- test1() ---------------------------" << std::endl;

    vector vec;
    vec.reserve(10);
    std::cout << "------ push_back --------" << std::endl;
    vec.push_back(ItemData(111, "hello"));
    std::cout << "------ emplace_back --------" << std::endl;
    vec.emplace_back(ItemData(222, "world"));
    std::cout << "-------- finish -------- " << std::endl;
}

void test2() {
    std::cout << "------------------------ test2() --------------------------" << std::endl;

    vector vec;
    vec.reserve(10);
    std::cout << "------ push_back --------" << std::endl;
    vec.push_back(ItemData(333, "stl"));
    std::cout << "------ emplace_back --------" << std::endl;
    vec.emplace_back(444, "vector");
    std::cout << "-------- finish -------- " << std::endl;
}

void vector_test() {
    test1();
    std::cout << std::endl << std::endl;
    test2();
}

int main() {

    vector_test();

    return 0;
}

1.2 vector清除内存

#include 
#include 

using namespace std;

// 方法一：std::vector().swap
void empty1(std::vector &iVec) {
    std::vector().swap(iVec);
}

// 方法二：clear() + shrink_to_fit()
void empty2(std::vector &iVec) {
    iVec.clear();
    iVec.shrink_to_fit();
}

// 方法三：std::move语义转移清空
void empty3(std::vector &iVec) {
    auto data = std::move(iVec);
}

// C++11增加接口shrink_to_fit()删除不存储数据的多余内存

void test1() {
     std::vector iVec;
    iVec.push_back(111);
    iVec.push_back(222);
    iVec.push_back(333);
    iVec.push_back(444);
    iVec.push_back(555);

    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
    empty1(iVec);
    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
}

void test2() {
     std::vector iVec;
    iVec.push_back(111);
    iVec.push_back(222);
    iVec.push_back(333);
    iVec.push_back(444);
    iVec.push_back(555);

    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
    empty2(iVec);
    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
}

void test3() {
     std::vector iVec;
    iVec.push_back(111);
    iVec.push_back(222);
    iVec.push_back(333);
    iVec.push_back(444);
    iVec.push_back(555);

    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
    empty3(iVec);
    std::cout << iVec.size() << " " << iVec.capacity() << std::endl;
}

int main(int argc, char *argv[])
{
    test1();
    test2();
    test3();

    return 0; 
}

2.排序

2.1 冒泡排序

#include

using namespace std;

void show_arr(int arr[], int iLen) {
    for (int i = 0; i < iLen; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

void bubbling_sort(int arr[], int iLen) {
    int iTemp = 0;
     for (int i = 0; i < iLen - 1; i++) {
        for (int j = i + 1; j < iLen; j++) {
            if (arr[i] > arr[j]) {
                iTemp = arr[i];
                arr[i] = arr[j];
                arr[j] = iTemp;
            }
        }
    }
} 

void test_bubbling_sort() {
    int arr[10] = {90, 18, 3, 56, 32, 45, 23, 21, 9, 51};
    int iLen = sizeof(arr) / sizeof(arr[0]);
    std::cout << "before sort:: ";
    show_arr(arr, iLen);
    bubbling_sort(arr, iLen);
    std::cout << "afort sort:: ";
    show_arr(arr, iLen);
}

int main() {

    test_bubbling_sort();

    return 0;
}

2.2 快速排序

#include 
#include 
#include 

using namespace std;

void show_arr(int arr[], int iLen) {
    for (int i = 0; i < iLen; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

void swap(int& a, int& b) {
    int iTmp = a;
    a = b;
    b = iTmp;
}

void quick_sort(int iArr[], int iLow, int iHigh) {
    if (iLow >= iHigh) {
        return;
    }
    int iKey = 0;
    iKey = iArr[iLow];
    int i = iLow;
    int j = iHigh;
    while (i < j) {
        while (iArr[i] <= iKey && i < iHigh) {
            i++;
        }
        while (iArr[j] >= iKey && j > iLow) {
            j--;
        }
        if (i >= j) {
            break;
        }

        swap(iArr[i], iArr[j]);
        
    }
    
    swap(iArr[iLow], iArr[j]);

    //show_arr(iArr, 10);

    quick_sort(iArr, iLow, j - 1);
    quick_sort(iArr, j + 1, iHigh);
}



void test_quick_sort() {
    int arr[10] = {90, 18, 3, 56, 32, 45, 23, 21, 9, 51};
    int iLen = sizeof(arr) / sizeof(arr[0]);
    std::cout << "before sort:: ";
    show_arr(arr, iLen);
    quick_sort(arr, 0, iLen - 1);
    std::cout << "afort sort:: ";
    show_arr(arr, iLen);
}

int main(int argc, char *argv[])
{
    test_quick_sort();
    return 0; 
}

2.3 堆排序

#include 
#include 
#include 

using namespace std;

void show_arr(int arr[], int iLen) {
    for (int i = 0; i < iLen; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

void swap(int& a, int& b) {
    int iTmp = a;
    a = b;
    b = iTmp;
}

void build_max_heap(int iArr[], int n) {
    if (n < 2) {
        return;
    }

    //计算开始堆构建位置
    int i = n / 2 - 1;
    int left = 0;
    int right = 0;
    int iMax = 0;
    while (i >= 0) {
        left = 2 * i + 1;
        right = 2 * i + 2;
        iMax = iArr[left];
        //有右子树时
        if (right < n) {
            if (iArr[right] > iArr[left] ) {
                iMax = iArr[right];
            }
        }
        if (iMax > iArr[i]) {
            // 左子树大时父节点和左节点交换
            if (iMax == iArr[left]) {
                swap(iArr[i], iArr[left]);
            }
            else {// 右子树大时父节点和右节点交换
                swap(iArr[i], iArr[right]);
            }
        }
        i--;
    }
}

// 从小到大排序，先构建大根堆，然后用第一个和最后一个交换， 最后一个就是最大值，跳过最后一个继续构建大根堆
// 然后用第一个和倒数第二个交换，倒数第二个就是第二大，跳过最后两个继续构建大根堆
void heap_sort(int iArr[], int iLen) {
    if (!iArr || iLen < 0) {
        return;
    }

    for (int i = iLen; i >= 1; i--) {
        build_max_heap(iArr, i);
        swap(iArr[0], iArr[i - 1]);
        
    }
}

void test_heap_sort() {
    int arr[10] = {90, 18, 3, 56, 32, 45, 23, 21, 9, 51};
    int iLen = sizeof(arr) / sizeof(arr[0]);
    std::cout << "before sort:: ";
    show_arr(arr, iLen);
    heap_sort(arr, iLen);
    std::cout << "afort sort:: ";
    show_arr(arr, iLen);
}

int main(int argc, char *argv[])
{
    test_heap_sort();
    return 0; 
}

3.内存

3.1 实现memset函数

#include

using namespace std;

void* my_memcpy(void* pDest, void* pSrc, unsigned int iCount) {
    if (!pDest || !pSrc) {
        return NULL;
    }
    char *pD = (char*)pDest;
    char *pS = (char*)pSrc;
    if (pD <= pS || pD >= (pS + iCount)) {
        while (iCount--) {
            *pD++ = *pS++;
        }
    }
    else { //内存重叠处理
        pD = (char*)pDest + iCount - 1;
        pS = (char*)pSrc + iCount - 1;
        while (iCount--) {
            *pD-- = *pS--;
        }
    }
    return pDest;
}


int main() {

    char tmpBuf[128] = "111111222222333333444444";
    char destBuf[128] = {0};

    std::cout << "1 " << (char*)my_memcpy(destBuf, tmpBuf, 10) << std::endl;
    std::cout << "2 " << destBuf << std::endl;
    std::cout << "3 " << (char*)my_memcpy(tmpBuf + 5, tmpBuf, 10) << std::endl;
    std::cout << "4 " << tmpBuf << std::endl;


    return 0;
}

4.链表

2.1 冒泡排序

#include

using namespace std;

struct Node {
    int data;
    Node* pNext;
};

//构建链表
void build_list(Node*& pHead) {
    pHead = new Node;
    pHead->data = 90;
    Node* pNode1 = new Node;
    pNode1->data = 18;
    pHead->pNext = pNode1;
    Node* pNode2 = new Node;
    pNode2->data = 3;
    pNode1->pNext = pNode2;
    Node* pNode3 = new Node;
    pNode3->data = 56;
    pNode2->pNext = pNode3;
    Node* pNode4 = new Node;
    pNode4->data = 32;
    pNode3->pNext = pNode4;
    Node* pNode5 = new Node;
    pNode5->data = 45;
    pNode4->pNext = pNode5;
    Node* pNode6 = new Node;
    pNode6->data = 23;
    pNode5->pNext = pNode6;
    Node* pNode7 = new Node;
    pNode7->data = 21;
    pNode6->pNext = pNode7;
    Node* pNode8 = new Node;
    pNode8->data = 9;
    pNode7->pNext = pNode8;
    Node* pNode9 = new Node;
    pNode9->data = 51;
    pNode8->pNext = pNode9;
    pNode9->pNext = nullptr;
}

//遍历链表内容
void show_list(Node* pHead) {
    Node* tmp = pHead;
    while (tmp) {
        std::cout << tmp->data << " "; 
        tmp = tmp->pNext;
    }
    std::cout << std::endl;
}

//链表冒泡排序
void list_bubbling_sort(Node* pHead) {
    if (!pHead) {
        return;
    }
    Node* pDeal = pHead;
    while (pDeal) {
        Node* pBack = pDeal ->pNext;
        while (pBack) {
            if (pDeal->data > pBack->data) {
                int iTemp = pDeal->data;
                pDeal->data = pBack->data;
                pBack->data = iTemp;
            }
            pBack = pBack->pNext;
        }
        pDeal = pDeal->pNext;
    }
}

int main() {

    Node* pHead = nullptr;
    build_list(pHead);
    show_list(pHead);
    list_bubbling_sort(pHead);
    show_list(pHead);

    return 0;
}

2.2 逆序

#include

using namespace std;

struct Node {
    int data;
    Node* pNext;
};

//构建链表
void build_list(Node*& pHead) {
    pHead = new Node;
    pHead->data = 90;
    Node* pNode1 = new Node;
    pNode1->data = 18;
    pHead->pNext = pNode1;
    Node* pNode2 = new Node;
    pNode2->data = 3;
    pNode1->pNext = pNode2;
    Node* pNode3 = new Node;
    pNode3->data = 56;
    pNode2->pNext = pNode3;
    Node* pNode4 = new Node;
    pNode4->data = 32;
    pNode3->pNext = pNode4;
    Node* pNode5 = new Node;
    pNode5->data = 45;
    pNode4->pNext = pNode5;
    Node* pNode6 = new Node;
    pNode6->data = 23;
    pNode5->pNext = pNode6;
    Node* pNode7 = new Node;
    pNode7->data = 21;
    pNode6->pNext = pNode7;
    Node* pNode8 = new Node;
    pNode8->data = 9;
    pNode7->pNext = pNode8;
    Node* pNode9 = new Node;
    pNode9->data = 51;
    pNode8->pNext = pNode9;
    pNode9->pNext = nullptr;
}

//遍历链表内容
void show_list(Node* pHead) {
    Node* tmp = pHead;
    while (tmp) {
        std::cout << tmp->data << " "; 
        tmp = tmp->pNext;
    }
    std::cout << std::endl;
}

// 链表反转1: 从第一个元素循环 
void reverse_list1(Node* &pHead) {
    if (!pHead || !pHead->pNext) {
        return;
    }
    Node* pCurNode = pHead;
    Node* pNextNode = nullptr;
    Node* pPreNode = nullptr;
    while (pCurNode) {
        pNextNode = pCurNode->pNext;
        pCurNode->pNext = pPreNode;
        pPreNode = pCurNode;
        pCurNode = pNextNode; 
    }
    pHead = pPreNode;

}

// 链表反转2: 从第二个元素循环
void reverse_list2(Node** pHead) {
    if (!pHead || !(*pHead)->pNext) {
        return;
    }
    Node* pCurNode = *pHead;
    Node* pNextNode = (*pHead)->pNext;
    (*pHead)->pNext = nullptr;
    while (pNextNode) {
        Node* pTmpNode = pNextNode->pNext; 
        pNextNode->pNext = pCurNode;
        pCurNode = pNextNode;
        pNextNode = pTmpNode;        
    }
    *pHead = pCurNode;
}


int main() {

    Node* pHead = nullptr;
    build_list(pHead);
    show_list(pHead);
    //reverse_list1(pHead);
    reverse_list2(&pHead);
    show_list(pHead);

    return 0;
}

2.2 合并

（1）修改原始链表的合并

#include

using namespace std;

struct Node {
    int data;
    Node* pNext;
};

//链表冒泡排序
void list_bubbling_sort(Node* pHead) {
    if (!pHead) {
        return;
    }
    Node* pDeal = pHead;
    while (pDeal) {
        Node* pBack = pDeal ->pNext;
        while (pBack) {
            if (pDeal->data > pBack->data) {
                int iTemp = pDeal->data;
                pDeal->data = pBack->data;
                pBack->data = iTemp;
            }
            pBack = pBack->pNext;
        }
        pDeal = pDeal->pNext;
    }
}

//构建链表
void build_list(Node*& pHead) {
    pHead = new Node;
    pHead->data = 90;
    Node* pNode1 = new Node;
    pNode1->data = 18;
    pHead->pNext = pNode1;
    Node* pNode2 = new Node;
    pNode2->data = 3;
    pNode1->pNext = pNode2;
    Node* pNode3 = new Node;
    pNode3->data = 56;
    pNode2->pNext = pNode3;
    Node* pNode4 = new Node;
    pNode4->data = 32;
    pNode3->pNext = pNode4;
    Node* pNode5 = new Node;
    pNode5->data = 45;
    pNode4->pNext = pNode5;
    Node* pNode6 = new Node;
    pNode6->data = 23;
    pNode5->pNext = pNode6;
    Node* pNode7 = new Node;
    pNode7->data = 21;
    pNode6->pNext = pNode7;
    Node* pNode8 = new Node;
    pNode8->data = 9;
    pNode7->pNext = pNode8;
    Node* pNode9 = new Node;
    pNode9->data = 51;
    pNode8->pNext = pNode9;
    pNode9->pNext = nullptr;
}

//遍历链表内容
void show_list(Node* pHead) {
    Node* tmp = pHead;
    while (tmp) {
        std::cout << tmp->data << " "; 
        tmp = tmp->pNext;
    }
    std::cout << std::endl;
}

//有序链表合并成， 修改原始链表
void merge_list1(Node* pHead1, Node* pHead2, Node* &pHead) {
    if (!pHead1 && !pHead2) {
        return;
    }

    if (!pHead1) {
        pHead = pHead2;
        return;
    }

    if (!pHead2) {
        pHead = pHead1;
        return;
    }
    if (pHead1->data < pHead2->data) {
        pHead = pHead1;
        pHead1 = pHead1->pNext;
    }
    else {
        pHead = pHead2;
        pHead2 = pHead2->pNext;
    }
    
    Node* pCurNode = pHead;
    while (pHead1 && pHead2) {
        if (pHead1->data < pHead2->data) {
            pCurNode->pNext = pHead1;
            pHead1 = pHead1->pNext;
        }
        else {
            pCurNode->pNext = pHead2;
            pHead2 = pHead2->pNext;
        }
        pCurNode = pCurNode->pNext;
    }
     
    if (!pHead1) {
        pCurNode->pNext = pHead2;
        return;
    }

    if (!pHead2) {
        pCurNode->pNext = pHead1;
        return;
    }   
}

// 修改原始列表合并的测试
void merge_list_test1() {
    Node* pHead1;
    Node* pHead2;

    //构建链表
    build_list(pHead1);
    build_list(pHead2);
    show_list(pHead1);
    show_list(pHead2);

    //排序列表
    list_bubbling_sort(pHead1);
    list_bubbling_sort(pHead2);
    show_list(pHead1);
    show_list(pHead2);

    //合并链表
     Node* pHead;
     merge_list1(pHead1, pHead2, pHead);
     show_list(pHead1);
     show_list(pHead2);
     show_list(pHead);
}


int main() {
    merge_list_test1();

    return 0;
}

（2）不修改原始链表的合并

#include

using namespace std;

struct Node {
    int data;
    Node* pNext;
};

//链表冒泡排序
void list_bubbling_sort(Node* pHead) {
    if (!pHead) {
        return;
    }
    Node* pDeal = pHead;
    while (pDeal) {
        Node* pBack = pDeal ->pNext;
        while (pBack) {
            if (pDeal->data > pBack->data) {
                int iTemp = pDeal->data;
                pDeal->data = pBack->data;
                pBack->data = iTemp;
            }
            pBack = pBack->pNext;
        }
        pDeal = pDeal->pNext;
    }
}

//构建链表
void build_list(Node*& pHead) {
    pHead = new Node;
    pHead->data = 90;
    Node* pNode1 = new Node;
    pNode1->data = 18;
    pHead->pNext = pNode1;
    Node* pNode2 = new Node;
    pNode2->data = 3;
    pNode1->pNext = pNode2;
    Node* pNode3 = new Node;
    pNode3->data = 56;
    pNode2->pNext = pNode3;
    Node* pNode4 = new Node;
    pNode4->data = 32;
    pNode3->pNext = pNode4;
    Node* pNode5 = new Node;
    pNode5->data = 45;
    pNode4->pNext = pNode5;
    Node* pNode6 = new Node;
    pNode6->data = 23;
    pNode5->pNext = pNode6;
    Node* pNode7 = new Node;
    pNode7->data = 21;
    pNode6->pNext = pNode7;
    Node* pNode8 = new Node;
    pNode8->data = 9;
    pNode7->pNext = pNode8;
    Node* pNode9 = new Node;
    pNode9->data = 51;
    pNode8->pNext = pNode9;
    pNode9->pNext = nullptr;
}

//遍历链表内容
void show_list(Node* pHead) {
    Node* tmp = pHead;
    while (tmp) {
        std::cout << tmp->data << " "; 
        tmp = tmp->pNext;
    }
    std::cout << std::endl;
}

//有序链表合并成， 不修改原始链表
void merge_list2(Node* pHead1, Node* pHead2, Node* &pHead) {
    if (!pHead1 && !pHead2) {
        return;
    }
    pHead = new Node;
    Node* pCurNode = pHead;
    if (!pHead1) {
        while (pHead2) {
            pCurNode->data = pHead2->data;
            pHead2 = pHead2->pNext;
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext;
            pCurNode->pNext = nullptr;
        }
        return;
    }

    if (!pHead2) {
        while (pHead1) {
            pCurNode->data = pHead1->data;
            pHead1 = pHead1->pNext;
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext;
            pCurNode->pNext = nullptr;
        }
        return;
    }
    if (pHead1->data < pHead2->data) {
        pCurNode->data = pHead1->data;
        pHead1 = pHead1->pNext;
    }
    else {
        pCurNode->data = pHead2->data;
        pHead2 = pHead2->pNext;
    }
    
    while (pHead1 && pHead2) {
        if (pHead1->data < pHead2->data) {
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext ;
            pCurNode->data = pHead1->data;
            pHead1 = pHead1->pNext; 
        }
        else {
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext ;
            pCurNode->data = pHead2->data;
            pHead2 = pHead2->pNext;
        }
    }
     
    if (!pHead1) {
        while (pHead2) {
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext ;
            pCurNode->data = pHead2->data;
            pHead2 = pHead2->pNext;
        }
        pCurNode->pNext = nullptr;
        return;
    }

    if (!pHead2) {
        while (pHead1) {
            pCurNode->pNext = new Node;
            pCurNode = pCurNode->pNext ;
            pCurNode->data = pHead1->data;
            pHead1 = pHead1->pNext; 
        }
        pCurNode->pNext = nullptr;
        return;
    }   
}

// 不修改原始列表合并的测试
void merge_list_test2() {
    Node* pHead1;
    Node* pHead2;

    //构建链表
    build_list(pHead1);
    build_list(pHead2);
    show_list(pHead1);
    show_list(pHead2);

    //排序列表
    list_bubbling_sort(pHead1);
    list_bubbling_sort(pHead2);
    show_list(pHead1);
    show_list(pHead2);

    //合并链表
    Node* pHead;
    merge_list2(pHead1, pHead2, pHead);
    show_list(pHead1);
    show_list(pHead2);
    show_list(pHead);
}

int main() {
    merge_list_test2();

    return 0;
}

5.缓存

5.1 最近最少使用（LRU）

#include
#include 
#include 

using namespace std;

// std::list存放key
// std::map 存放 key -> (vaue, key在std::list中的位置)
// 存放: key存放在list头部，map中存放key，value以及key在list中的具体位置
// 取值: key 在map中找到vaue以及keystd::list的位置，位置如果不在最前面，则删除重新插入
// 删除：从list尾部进行删除

class lru_cache
{
public:
    lru_cache(size_t capacity)
        : m_capacity(capacity)
    {
    }

    ~lru_cache()
    {
    }

    size_t size() const
    {
        return m_map.size();
    }

    size_t capacity() const
    {
        return m_capacity;
    }

    bool empty() const
    {
        return m_map.empty();
    }

    bool contains(const int &key)
    {
        return m_map.find(key) != m_map.end();
    }

    // 插入新值
    void insert(const int &key, const int &value)
    {
        std::map::iterator>>::iterator i = m_map.find(key);
        if(i == m_map.end()){
            if(size() >= m_capacity){
                evict();
            }
            // 新来的数据对应key放入链表头部
            m_list.push_front(key);
            // map中存放key，value及其key在链表中的位置
            m_map[key] = std::make_pair(value, m_list.begin());
        }
    }

    // 获取key对应value
    int get(const int &key)
    {
        std::map::iterator>>::iterator i = m_map.find(key);
        if(i == m_map.end()){
            return 0;
        }

        // 根据map迭代器找到key在链表中的位置
        std::list::iterator j = i->second.second;
        // 新访问的数据必须放在最开始位置
        if(j != m_list.begin()){
            // 不在最开始位置将原来的进行删除，然后将其插入，插入一定是在最开始的位置
            m_list.erase(j);
            m_list.push_front(key);

            j = m_list.begin();
            const int &value = i->second.first;
            m_map[key] = std::make_pair(value, j);

            return value;
        }
        else {
            return i->second.first;
        }
    }

    void clear()
    {
        m_map.clear();
        m_list.clear();
    }

private:
    void evict()
    {
        std::list::iterator i = --m_list.end();
        m_map.erase(*i);
        m_list.erase(i);
    }

private:
    //存放key， ，选择map是为了方便查找，存储key在list中的位置是为了在list快速删除
    std::map::iterator>> m_map;
    //存放key，选择list是为了方便在一定容量内进行插入和删除
    std::list m_list;
    size_t m_capacity;
};


int main(int argc, char *argv[])
{
   lru_cache lruCache(10);

    return 0; 
}

6.字符串

6.1 点分ipv4地址格式化处理

#include 
#include 
#include 

using namespace std;

int main() {
    std::string str;

    int iData = 0, iData1, iData2, iData3;
    sscanf("123.12.34.56", "%d.%d.%d.%d", &iData, &iData1, &iData2, &iData3);
    std::cout << iData << std::endl;
    std::cout << iData1 << std::endl;
    std::cout << iData2 << std::endl;
    std::cout << iData3 << std::endl;

    char tmpBuf[1024] = {0};
    sprintf(tmpBuf, "%d.%d.%d.%d", iData, iData1, iData2, iData3);
    std::cout << tmpBuf << std::endl;

    return 0;
}

6.2 字符串拆分

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

std::vector split(const char* pStr, char sepor) {
    std::vector strVec;
    if (!pStr) {
        return strVec;
    }
    int iLen = strlen(pStr);
    std::string str;
    for (int i = 0; i < iLen; i++) {
        if (sepor == *(pStr + i)) {
            if (!str.empty()) {
                strVec.emplace_back(str);
                str.clear();
            }
        }
        else {
            str.push_back(*(pStr + i));
        }
    }
}


std::vector split(const std::string& str, char sparator) {
    if (str.empty()) {
        return std::vector();
    }
    std::vector strVec;
    int iCurPos = 0, iLastPos = 0;
    while (std::string::npos != (iCurPos = str.find(sparator, iLastPos))) {
        if (iLastPos != iCurPos) {
            strVec.emplace_back(str.substr(iLastPos, iCurPos - iLastPos));
        }
        iLastPos = ++iCurPos;
    }

    return strVec;
}


int main() {
    std::vector strVec = split("A10;D20;E30;W40;;;;", ';');
    for (const auto & item : strVec) {
        std::cout << item << std::endl;
    }

    return 0;
}

6.3 查找最长重复子串

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;


void findMaxRepeatSubStr(const std::string &str, std::string &strMaxSub) {
    int iLen = str.size();
    if (iLen <= 1) {
        return;
    }
    std::map siMap;
    std::string strSub;
    int iPos = -1;
    // 按照个数从 1 -> iLen / 2查找子串
    for (int iNum = 1; iNum <= iLen / 2; iNum++) {
        for (int i = 0; i < iLen; i++) {
            strSub = str.substr(i, iNum);
            if (strSub.length() != iNum) {
                strSub.clear();
                continue;
            }
            if (siMap.end() == siMap.find(strSub)) {
                siMap[strSub] = 1;
            } else {
                siMap[strSub]++;
            } 
        }
    } 
    //遍历查找最长重复子串
    std::map::iterator iter = siMap.end();
    int iMax = 0;
    for (auto item = siMap.begin(); item != siMap.end(); item++) {
        if (item->second > 1 && item->first.length() > iMax) {
            iter = item;
            iMax = item->first.length();
        }
    }
    if (iter != siMap.end()) {
        strMaxSub = iter->first;
    }
}


int main() {
    std::string str;
    
    findMaxRepeatSubStr("abcabcdacdacda", str);
    std::cout << str << std::endl;

    return 0;
}

7.IO流

7.1 字符串和文件IO流

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

//文件输出流
void test_of() {
   std::ofstream of("test.txt", std::ios::out | std::ios::app);
   if (of) {
    of << 123 << std::endl;
    of << "hello worl" << std::endl;
   }
   of.close();
}

//文件输入流
void test_if() {
    std::ifstream ifs("test.txt", std::ios::in);
    int iData = 0;
    std::string str;
    
    // 一次读取一个单词
    /*
    while (!ifs.eof()) {
        str.clear();
        ifs >> str;
        //文件最后一行是空白行
        if (ifs.eof() && str.empty()) {
            break;
        }
        std::cout << str << std::endl;
    }
    */

    //一次读取一行
    while (std::getline(ifs, str)) {
        if (str.empty()) {
            continue;
        }
        std::cout << str << std::endl;
    }

    ifs.close();
}

//字符串io流
void test_sstream() {
    std::stringstream istr;
    istr << "hello\n" << std::endl << "qazsedc" << std::endl << "AAAAAA" << std::endl << std::endl;
    std::string str;
    istr >> str;

    while (std::getline(istr, str)) {
        if (str.empty()) {
            continue;
        }
        std::cout << str << std::endl;
    }
}

int main() {

    test_of();
    test_if();

    return 0;
}

8.VC++

8.1 Mutex和临界区

忘记释放Mutex和临界区的线程会一直运行，并不会出现死锁

#include "stdafx.h"
#include 
#include 
#include 
#include 

using namespace std;

HANDLE hMutex = NULL;

CRITICAL_SECTION g_cs;

DWORD WINAPI ThreadFun1(LPVOID lpParam)
{
	while (true) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << (int)lpParam << endl;
		Sleep(1000);
		ReleaseMutex(hMutex);
	}
	
	return(0);
}

DWORD WINAPI ThreadFun2(LPVOID lpParam)
{
	while (true) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << (int)lpParam << endl;
		Sleep(1000);
		//ReleaseMutex(hMutex);
	}
	
	return(0);
}

DWORD WINAPI ThreadFun3(LPVOID lpParam)
{
	while (true) {
		EnterCriticalSection(&g_cs);
		cout << (int)lpParam << endl;
		Sleep(1000);
		LeaveCriticalSection(&g_cs);
	}

	return(0);
}

DWORD WINAPI ThreadFun4(LPVOID lpParam)
{
	while (true) {
		EnterCriticalSection(&g_cs);
		cout << (int)lpParam << endl;
		Sleep(1000);
		//LeaveCriticalSection(&g_cs);
	}

	return(0);
}

void  test_mutex() {
	HANDLE hThread = NULL;
	DWORD dwThreadId;

	hMutex = CreateMutex(NULL, true, "true");
	ReleaseMutex(hMutex);
	hThread = CreateThread(NULL, 0, ThreadFun1, (LPVOID)1, 0, &dwThreadId);
	hThread = CreateThread(NULL, 0, ThreadFun2, (LPVOID)2, 0, &dwThreadId);

	getchar();
	system("pause");
	CloseHandle(hThread);
	CloseHandle(hMutex);
}

void  test_section() {
	DWORD dwThreadId;
	InitializeCriticalSection(&g_cs);
	HANDLE hThread1 = CreateThread(NULL, 0, ThreadFun3, (LPVOID)3, 0, &dwThreadId);
	HANDLE hThread2 = CreateThread(NULL, 0, ThreadFun4, (LPVOID)4, 0, &dwThreadId);



	Sleep(400000);
	//关闭线程句柄
	CloseHandle(hThread1);
	CloseHandle(hThread2);

	//关闭事件对象句柄
	DeleteCriticalSection(&g_cs);
}

你可能感兴趣的:(c++)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题（第三大题：完善程序代码） mmz1207 c++csp
最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
20个新手学习c++必会的程序输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
《 C++ 修炼全景指南：十》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南 c++数据结构 stl
摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念 c++c语言开发语言青少年编程
文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
C++常见知识掌握 nfgo c++开发语言
1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
metaRTC5.0 API编程指南(一) metaRTC metaRTC c++c语言 webrtc
概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
sublime个人设置 bawangtianzun sublime text 编辑器
如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗源码编译与开发 rust c语言 c++内存安全并发编程代码安全性能优化
目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
Python开发游戏？也太好用了吧七步编程工具 Github python python 游戏开发语言
程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
OpenCV图像处理技术（Python）——入门森屿_ opencv
©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
linux gcc 格式,Linux下gcc与gdb简介神奇的战士 linux gcc 格式
gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
浅谈openresty 爱编码的钓鱼佬 nginx openresty 运维
熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
Java【泛型】 SkyrimCitadelValinor Java基础 java
Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
Spring4.1新特性——综述 jinnianshilongnian spring 4.1
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
Schema与数据类型优化 annan211 数据结构 mysql
目前商城的数据库设计真是一塌糊涂，表堆叠让人不忍直视，无脑的架构师，说了也不听。在数据库设计之初，就应该仔细揣摩可能会有哪些查询，有没有更复杂的查询，而不是仅仅突出很表面的业务需求，这样做会让你的数据库性能成倍提高，当然，丑陋的架构师是不会这样去考虑问题的。选择优化的数据类型 1 更小的通常更好更小的数据类型通常更快，因为他们占用更少的磁盘、内存和cpu缓存，
第一节 HTML概要学习 chenke html Web css
第一节 HTML概要学习 1. 什么是HTML HTML是英文Hyper Text Mark-up Language(超文本标记语言)的缩写，它规定了自己的语法规则，用来表示比“文本”更丰富的意义，比如图片，表格，链接等。浏览器（IE,FireFox等）软件知道HTML语言的语法，可以用来查看HTML文档。目前互联网上的绝大部分网页都是使用HTML编写的。打开记事本输入一下内
MyEclipse里部分习惯的更改 Array_06 eclipse
继续补充中---------------------- 1.更改自己合适快捷键windows-->prefences-->java-->editor-->Content Assist--> Activation triggers for java的右侧“.”就可以改变常用的快捷键选中 Text
近一个月的面试总结 cugfy 面试
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/46753275 前言打算换个工作，近一个月面试了不少的公司，下面将一些面试经验和思考分享给大家。另外校招也快要开始了，为在校的学生提供一些经验供参考，希望都能找到满意的工作。
HTML5一个小迷宫游戏 357029540 html5
通过《HTML5游戏开发》摘抄了一个小迷宫游戏，感觉还不错，可以画画，写字，把摘抄的代码放上来分享下，喜欢的同学可以拿来玩玩！ <html> <head> <title>创建运行迷宫</title> <script type="text/javascript"
10步教你上传githib数据张亚雄 git
官方的教学还有其他博客里教的都是给懂的人说得，对已我们这样对我大菜鸟只能这么来锻炼，下面先不玩什么深奥的，先暂时用着10步干净利索。等玩顺溜了再用其他的方法。操作过程（查看本目录下有哪些文件NO.1）ls （跳转到子目录NO.2）cd+空格+目录（继续NO.3）ls （匹配到子目录NO.4）cd+ 目录首写字母+tab键+（首写字母“直到你所用文件根就不再按TAB键了”）（查看文件
MongoDB常用操作命令大全 adminjun mongodb 操作命令
成功启动MongoDB后，再打开一个命令行窗口输入mongo，就可以进行数据库的一些操作。输入help可以看到基本操作命令，只是MongoDB没有创建数据库的命令，但有类似的命令如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。一
bat调用jar包并传入多个参数 aijuans
下面的主程序是通过eclipse写的： 1.在Main函数接收bat文件传递的参数（String[] args）如： String ip =args[0]; String user=args[1]; &nbs
Java中对类的主动引用和被动引用 ayaoxinchao java 主动引用对类的引用被动引用类初始化
在Java代码中，有些类看上去初始化了，但其实没有。例如定义一定长度某一类型的数组，看上去数组中所有的元素已经被初始化，实际上一个都没有。对于类的初始化，虚拟机规范严格规定了只有对该类进行主动引用时，才会触发。而除此之外的所有引用方式称之为对类的被动引用，不会触发类的初始化。虚拟机规范严格地规定了有且仅有四种情况是对类的主动引用，即必须立即对类进行初始化。四种情况如下：1.遇到ne
导出数据库提示 outfile disabled BigBird2012 mysql
在windows控制台下，登陆mysql，备份数据库： mysql>mysqldump -u root -p test test > D:\test.sql 使用命令 mysqldump 格式如下： mysqldump -u root -p *** DBNAME > E:\\test.sql。注意：执行该命令的时候不要进入mysql的控制台再使用，这样会报
Javascript 中的 && 和 || bijian1013 JavaScript &&||
准备两个对象用于下面的讨论 var alice = { name: "alice", toString: function () { return this.name; } } var smith = { name: "smith",
[Zookeeper学习笔记之四]Zookeeper Client Library会话重建 bit1129 zookeeper
为了说明问题，先来看个简单的示例代码： package com.tom.zookeeper.book; import com.tom.Host; import org.apache.zookeeper.WatchedEvent; import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.Wat
【Scala十一】Scala核心五：case模式匹配 bit1129 scala
package spark.examples.scala.grammars.caseclasses object CaseClass_Test00 { def simpleMatch(arg: Any) = arg match { case v: Int => "This is an Int" case v: (Int, String)
运维的一些面试题 yuxianhua linux
1、Linux挂载Winodws共享文件夹 mount -t cifs //1.1.1.254/ok /var/tmp/share/ -o username=administrator,password=yourpass 或 mount -t cifs -o username=xxx,password=xxxx //1.1.1.1/a /win
Java lang包-Boolean BrokenDreams boolean
Boolean类是Java中基本类型boolean的包装类。这个类比较简单，直接看源代码吧。 public final class Boolean implements java.io.Serializable,
读《研磨设计模式》-代码笔记-命令模式-Command bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.Collection; import java.util.List; /** * GOF 在《设计模式》一书中阐述命令模式的意图：“将一个请求封装
matlab下GPU编程笔记 cherishLC matlab
不多说，直接上代码 gpuDevice % 查看系统中的gpu,,其中的DeviceSupported会给出matlab支持的GPU个数。 g=gpuDevice(1); %会清空 GPU 1中的所有数据,,将GPU1 设为当前GPU reset(g) %也可以清空GPU中数据。 a=1; a=gpuArray(a); %将a从CPU移到GPU中 onGP
SVN安装过程 crabdave SVN
SVN安装过程 subversion-1.6.12 ./configure --prefix=/usr/local/subversion --with-apxs=/usr/local/apache2/bin/apxs --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr --with-openssl=/
sql　行列转换 daizj sql 行列转换行转列列转行
行转列的思想是通过case when 来实现列转行的思想是通过union all 来实现下面具体例子：假设有张学生成绩表(tb)如下: Name Subject Result 张三语文　　74 张三数学　　83 张三物理　　93 李四语文　　74 李四数学　　84 李四物理　　94 */ /* 想变成姓名 &
MySQL--主从配置 dcj3sjt126com mysql
linux下的mysql主从配置：说明：由于MySQL不同版本之间的(二进制日志)binlog格式可能会不一样，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者更低， Master的版本肯定不能高于Slave版本。（版本向下兼容） mysql1 : 192.168.100.1 //master mysq
关于yii 数据库添加新字段之后model类的修改 dcj3sjt126com Model
rules: array('新字段','safe','on'=>'search') 1、array('新字段', 'safe')//这个如果是要用户输入的话，要加一下， 2、array('新字段', 'numerical'),//如果是数字的话 3、array('新字段', 'length', 'max'=>100),//如果是文本 1、2、3适当的最少要加一条，新字段才会被
sublime text3 中文乱码解决 dyy_gusi Sublime Text
sublime text3中文乱码解决原因：缺少转换为UTF-8的插件目的：安装ConvertToUTF8插件包第一步：安装能自动安装插件的插件，百度“Codecs33”，然后按照步骤可以得到以下一段代码： import urllib.request,os,hashlib; h = 'eb2297e1a458f27d836c04bb0cbaf282' + 'd0e7a30980927
概念了解：CGI，FastCGI，PHP-CGI与PHP-FPM geeksun PHP
CGI CGI全称是“公共网关接口”(Common Gateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。 CGI可以用任何一种语言编写，只要这种语言具有标准输入、输出和环境变量。如php,perl,tcl等。 FastCGI FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不
Git push 报错 "error: failed to push some refs to " 解决 hongtoushizi git
Git push 报错 "error: failed to push some refs to " . 此问题出现的原因是：由于远程仓库中代码版本与本地不一致冲突导致的。由于我在第一次git pull --rebase 代码后，准备push的时候，有别人往线上又提交了代码。所以出现此问题。解决方案： 1： git pull 2：
第四章 Lua模块开发 jinnianshilongnian nginx lua
在实际开发中，不可能把所有代码写到一个大而全的lua文件中，需要进行分模块开发；而且模块化是高性能Lua应用的关键。使用require第一次导入模块后，所有Nginx 进程全局共享模块的数据和代码，每个Worker进程需要时会得到此模块的一个副本（Copy-On-Write），即模块可以认为是每Worker进程共享而不是每Nginx Server共享；另外注意之前我们使用init_by_lua中初
java.lang.reflect.Proxy liyonghui160com
1.简介 Proxy 提供用于创建动态代理类和实例的静态方法（1）动态代理类的属性代理类是公共的、最终的，而不是抽象的未指定代理类的非限定名称。但是，以字符串 "$Proxy" 开头的类名空间应该为代理类保留代理类扩展 java.lang.reflect.Proxy 代理类会按同一顺序准确地实现其创建时指定的接口
Java中getResourceAsStream的用法 pda158 java
1.Java中的getResourceAsStream有以下几种： 1. Class.getResourceAsStream(String path) ： path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。　　2. Class.getClassLoader.get
spring 包官方下载地址（非maven） sinnk spring
SPRING官方网站改版后，建议都是通过 Maven和Gradle下载，对不使用Maven和Gradle开发项目的，下载就非常麻烦，下给出Spring Framework jar官方直接下载路径: http://repo.springsource.org/libs-release-local/org/springframework/spring/ s
Oracle学习笔记(7) 开发PLSQL子程序和包 vipbooks oracle sql 编程
哈哈，清明节放假回去了一下，真是太好了，回家的感觉真好啊！现在又开始出差之旅了，又好久没有来了，今天继续Oracle的学习！这是第七章的学习笔记，学习完第六章的动态SQL之后，开始要学习子程序和包的使用了……，希望大家能多给俺一些支持啊！编程时使用的工具是PLSQL