月度归档： 2022年10月

#include <stdio.h>
#include <string.h>

#include <string>
using namespace std;

// 1号方式
void test(const string& t)
{
}
// 2号方式
void test(string& t)
{
}
// 这种方式避免使用，请参考1号方式
void test(string t)
{
}

int main()
{
// 	string str1 ("LiMing");    // 以一个C风格字符串构造
// 	string str2 = "WangHua";  // 同上一种方式
// 	string str3 ("abcde", 3);    // 参数1是C字符串，参数2参数是长度
// 	string str4;  // 空字符串
// 	string str5 = "";  // 同上，空字符串

    // string str6 = NULL; // 不能初始化为NULL

    // 取得字符串内部的char*
    string text("hello,world!\n");
    const char* p = text.c_str();
    printf("str: %s \n", text.c_str());

    // 
    string t1;
    t1.append("something else");	// 附加一个字符串
    t1.append("abcde", 5);    // 附加一个字符串：拷贝前5个字符
    t1.append("abcde", 1, 3);  // 附加一个字符串：
    // 起点offset=1, 长度3，即拷贝"bcd"
    t1.append(4, 'h'); // 附加2个’h’字符

    // 考虑效率问题
    string t2;
    t2.resize(1024);
    t2.clear();
    t2.append("ab");
    t2.append("cd");

    // 
    string t3 = "hello";
    t3[1] = 'i'; // 推荐使用
    t3.at(1) = 'c'; // 不推荐

    // 字符串的比较
    string t4 = "yes";
    if( t4 == "yes")
    {
        printf("相等\n");
    }

    // 字符串的查找
    string t5 = "LiMing is doing homework";
    int p1 = t5.find('i');   // 返回1
    int p2 = t5.rfind('e');   // 
    // 存在，则返回其位置；否则，返回-1

    // 返回子串
    string t6 ("abcdefg");
    string r1 = t6.substr(4); // 返回"efg"
    string r2 = t6.substr(4,2); // 返回"ef"

    return 0;
}

list: 封装链表相关的功能

链表不能随机访问，只能按顺序链式访问，所以，只能使用迭代器iterator

list<T>::iterator， list内的迭代器

list比vector用适合插入删除操作

list链表中插入/删除一个节点
遍历list，找到目标位置
调用insert/erase，插入/删除一个节点

vector可有可无，但list不可或缺

vector不常用到，使用普通的数组完全没有问题。
list经常用到，如果没有list，那么每个链表都需要从头写起，非常麻烦。

#include <stdio.h>
#include <string.h>

#include <list>
using namespace std;

int main()
{
    list<int> lst;

    lst.push_back(1);
    lst.push_front(3);
    lst.push_front(2);
    //lst.pop_back();

    for(list<int>::iterator iter = lst.begin();
        iter != lst.end(); iter ++)
    {
        int& value = *iter;
        printf("%d, ", value);
    }

    // 删除值为3的节点
    for(list<int>::iterator iter = lst.begin();
        iter != lst.end(); iter ++)
    {
        int& value = *iter;
        if(value == 3)
        {
            lst.erase(iter);
            break;
        }
    }

    return 0;
}

#include <stdio.h>
#include <string.h>

#include <list>
using namespace std;


class Object
{
public:
    Object()
    {		
    }
    Object(int id, const char* name)
    {
        this->id = id;
        strcpy(this->name, name);
    }
public:
    int id;
    char name[32];
};

int main()
{
    list<Object> lst;
    lst.push_back(Object(1, "shaofa"));
    lst.push_back(Object(2, "xxxx"));
    lst.push_back(Object(3, "yyyy"));


    for(list<Object>::iterator iter = lst.begin();
        iter != lst.end(); iter ++)
    {
        Object& value = *iter;

        printf("%d, %s \n", value.id, value.name);
    }


    return 0;
}

#include <stdio.h>
#include <string.h>

#include <vector>
using namespace std;

int main()
{
    vector  <int >   arr(16);   // capacity:16
    arr.clear(); // size = 0

    arr.push_back (1) ;   //  capacity:16 , size : 1
    arr.push_back (2) ;   //  capacity:16 , size : 2
    int capacity = arr.capacity();
    int size = arr.size();

    // 迭代器遍历
    vector<int>::iterator iter;
    for(iter = arr.begin();  iter != arr.end(); iter ++)
    {
        int& value = *iter;
        printf("%d, ", value);
    }

    // 
// 	for(int i=0; i<arr.size(); i++)
// 	{
// 		int& value = arr[i];
// 		printf("%d, ", value);
// 	}

    return 0;
}

main.c

#include <stdio.h>
#include <string.h>

#include "Array.h"

int main()
{
    Array<int> a; // 长度可变的数组
    a.PushBack(1);
    a.PushBack(2);
    a.PushBack(3);
    a.PushBack(4);
    a.PushBack(5);

    int size = a.Size();

    Array<float> b;
    b.PushBack(2.3f);

    return 0;
}

Aarry.h

#ifndef _ARRAY_H
#define _ARRAY_H

// 用于存放double类型的对象
template <typename _TT>
class Array
{
public:
    Array(int capacity=4)
    {
        m_buffer = new _TT[capacity];
        m_capacity = capacity;
        m_size = 0;
    }

    void PushBack(_TT val)
    {
        if(m_size >= m_capacity)
        {
            Resize();
        }
        m_buffer[m_size] = val;
        m_size ++;
    }
    int Capacity()
    {
        return m_capacity;
    }
    int Size()
    {
        return m_size;
    }

private:
    void Resize()
    {
        // 创建一个更大的缓冲区
        int n = m_capacity + 4;
        _TT* buf = new _TT[n];

        // 拷贝原有的内容
        memcpy(buf, m_buffer, m_capacity * sizeof(_TT) );

        // 删除旧的内容,释放其内存
        delete [] m_buffer;

        // 更新一下成员变量
        m_capacity = n;
        m_buffer = buf;
    }

private:
    _TT* m_buffer;
    int m_capacity; // 容量
    int m_size; // 已经存放的对象的个数
};


#endif