罗剑锋的C++实战笔记学习（一）：const、智能指针、lambda表达式

1、const

1）、常量

const一般的用法就是修饰变量、引用、指针，修饰之后它们就变成了常量，需要注意的是const并未区分出编译期常量和运行期常量，并且const只保证了运行时不直接被修改

一般的情况，const放在左边，表示常量：

const int x = 100; // 常量
const int& rx = x; // 常量引用
const int* px = &x; // 常量指针

给变量加上const之后变量就成了常量，只能读、禁止写，编译器会帮你检查出所有对它的写操作，发出警告，在编译阶段防止有意或者无意的修改。这样一来，const常量用起来就相对安全一点。所以在设计函数的时候，将参数用const修饰的话，一个是可以保证效率，另一个是保证安全

2）、修饰成员函数

除此之外，const还能声明在成员函数上，const被放在了函数的后面，表示这个函数是一个常量，函数的执行过程是const的，不会修改对象的状态（即成员变量），比如：

class DemoClass final {
private:
    const long MAX_SIZE = 256; // const成员变量
    int m_value; // 成员变量
public:
    int get_value() const // const成员函数
    {
        // error: Cannot assign to non-static data member within const member function 'get_value'
        m_value = 100;
        return m_value;
    }
};
3）、指针常量

const放在*的右边，表示指针是常量（const pointer to int），指针不能被修改，而指向的变量可以被修改：

    int x = 100;
    int b = 150;
    int *const px = &x;
    *px = 102; // success
    px = &b; // error: Cannot assign to variable 'px' with const-qualified type 'int *const'

int *const px和const int* px的区别：

  • int *const px定义了一个指针常量，指针本身的地址不可改变，但可以改变指针所指向的数据
  • const int* px定义了一个指向常量的指针，可以改变指针的地址使其指向其他int，但不能通过此指针修改所指向的int值
4）、小结
const非const
对象（实例）const T：对象只读，只能调用const成员函数可以修改对象，调用任意成员函数
引用const T&：引用的对象只读，只能调用const成员函数
指针*const：指针指向的对象只读，只能调用const成员函数
成员函数func() const：不允许修改成员变量可以修改成员变量
指针常量const T*：表示指针是常量，指针不能被修改，而其指向的变量可以被修改指针和其指向的变量都可以被修改

2、智能指针

1）、unique_ptr

unique_ptr是一种独占资源所有权的指针，它会自动管理初始化时的指针，在离开作用域时析构释放内存

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr1(new int(10)); // int智能指针
    assert(*ptr1 == 10); // 使用*取内容
    assert(ptr1 != nullptr); // 判断是否为空指针

    std::unique_ptr<std::string> ptr2(new std::string("hello")); // string智能指针
    assert(*ptr2 == "hello"); // 使用*取内容
    assert(ptr2->size() == 5); // 使用->调用成员函数
    return 0;
}

在C++14的时候新加入了make_unique()函数，可以利用它构造一个unique_ptr对象：

#include <iostream>
#include <memory>

int main() {
    auto ptr1 = std::make_unique<int>(42); // 工厂函数创建智能指针
    assert(ptr1 && *ptr1 == 42);

    auto ptr2 = std::make_unique<std::string>("god of war"); // 工厂函数创建智能指针
    assert(!ptr2->empty());
    return 0;
}

unique_ptr的所有权：

unique_ptr表示指针的所有权是唯一的，不允许共享，任何时候只能有一个人持有它

为了实现这个目的，unique_ptr应用了C++的转移（move）语义，同时禁止了拷贝赋值，所以，在向另一个unique_ptr赋值的时候，要特别留意，必须用std::move()函数显式地声明所有权转移

赋值操作之后，指针的所有权就被转走了，原来的unique_ptr变成了空指针，新的unique_ptr接替了管理权，保证所有权的唯一性：

#include <iostream>
#include <memory>

int main() {
    auto ptr1 = std::make_unique<int>(42); // 工厂函数创建智能指针
    assert(ptr1 && *ptr1 == 42); // 此时智能指针有效

    auto ptr2 = std::move(ptr1); // 使用move()转移所有权
    assert(!ptr1 && ptr2); // ptr1变成了空指针
    return 0;
}

unique_ptr作为参数和返回值：

unique_ptr作为参数传递不会发生拷贝，但是会将对象所有权会转移到函数里，如下ptr会在main()方法结束之前被销毁：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }

    friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
        out << "I am a resource";
        return out;
    }
};

void takeOwnership(std::unique_ptr<Resource> res) {
    if (res) {
        std::cout << *res << '\n';
    }
} // Resource对象会在这里销毁

int main() {
    auto ptr{std::make_unique<Resource>()};
    // takeOwnership(ptr); // 不能这样写,unique_ptr禁止了拷贝赋值,需要使用std::move()函数显式地声明所有权转移
    takeOwnership(std::move(ptr));
    std::cout << "Ending program\n";
    return 0;
}

输出：

Resource acquired
I am a resource
Resource destroyed
Ending program

有时候不想对象的所有权转移到函数里，这时候可以通过get()方法获取对象，如下：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }

    friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
        out << "I am a resource";
        return out;
    }
};

void takeOwnership(Resource *res) {
    if (res) {
        std::cout << *res << '\n';
    } else {
        std::cout << "No resource\n";
    }
}

int main() {
    auto ptr{std::make_unique<Resource>()};
    takeOwnership(ptr.get());
    std::cout << "Ending program\n";
    return 0;
} // Resource对象会在这里销毁

输出：

Resource acquired
I am a resource
Ending program
Resource destroyed

unique_ptr可以直接作为返回值返回：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }

    friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
        out << "I am a resource";
        return out;
    }
};

std::unique_ptr<Resource> createResource() {
    return std::make_unique<Resource>();
}

int main() {
    auto ptr{createResource()};
    return 0;
}

在C++14及之前的版本中会使用std::move来返回Resource对象，在C++17及以后版本中进行了RVO优化（https://en.wikipedia.org/wiki/Copy_elision），尽管没有显式使用std::move，编译器依然能够识别并优化这个返回过程，直接将新创建的Resource对象的所有权从createResource函数内部转移到了main函数中的ptr变量，而无需实际执行移动构造函数

2）、shared_ptr

shared_ptr和unique_ptr不同是它的所有权是可以被安全共享的，也就是说支持拷贝赋值，允许被多个人同时持有，就像原始指针一样

在底层实现中，shared_ptr采用引用计数的方式实现。引用计数最开始的时候是1，表示只有一个持有者。如果发生拷贝赋值——也就是共享的时候，引用计数就增加（为了保证并发安全，引用计数器的加1，减1操作都是原子操作），而发生析构销毁的时候，引用计数就减少。只有当引用计数减少到0，也就是说，没有任何人使用这个指针的时候，它才会真正调用delete释放内存

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }
};

int main() {
    auto ptr1 = std::make_shared<Resource>(); // 工厂函数创建智能指针
    assert(ptr1 && ptr1.unique()); // 此时智能指针有效且唯一

    {
        auto ptr2 = ptr1; // 直接拷贝赋值,不需要使用move()
        assert(ptr1 && ptr2); // 此时两个智能指针均有效

        assert(ptr1 == ptr2); // shared_ptr可以直接比较
        
        // 两个智能指针均不唯一,且引用计数为2
        assert(!ptr1.unique() && ptr1.use_count() == 2);
        assert(!ptr2.unique() && ptr2.use_count() == 2);

        std::cout << "Killing one shared pointer\n";
    } // ptr2离开了作用域,但是没有资源被销毁

    assert(ptr1 && ptr1.unique()); // 此时智能指针有效且唯一
    std::cout << "Killing another shared pointer\n";
    return 0;
} // ptr1离开了作用域,Resource对象会在这里销毁

输出：

Resource acquired
Killing one shared pointer
Killing another shared pointer
Resource destroyed

在上面的例子中， ptr2在自己的作用域中被创建，然后出了作用域后ptr2虽然被销毁，但是所管理的资源却在main方法结束后才被销毁

enable_shared_from_this：

如果不小心直接在类里面返回this对象想要获得该对象的shared_ptr，那么会让一个对象被delete两次，如下：

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }

    std::shared_ptr<Resource> GetSPtr() {
        return std::shared_ptr<Resource>(this);
    }
};

int main() {
    auto sptr1 = std::make_shared<Resource>();
    auto sptr2 = sptr1->GetSPtr();
    return 0;
}

输出：

Resource acquired
Resource destroyed
studyProject(6959,0x7ff854f04700) malloc: *** error for object 0x6000035ed1f8: pointer being freed was not allocated
studyProject(6959,0x7ff854f04700) malloc: *** set a breakpoint in malloc_error_break to debug

上面的代码其实会生成两个独立的shared_ptr，他们的控制块是独立的，所以导致Resource被释放了两次

使用enable_shared_from_this可以避免上述情况：

#include <iostream>
#include <memory>

class Resource : public std::enable_shared_from_this<Resource> {
public:
    Resource() { std::cout << "Resource acquired\n"; }

    ~Resource() { std::cout << "Resource destroyed\n"; }

    std::shared_ptr<Resource> GetSPtr() {
        return shared_from_this();
    }
};

int main() {
    auto sptr1 = std::make_shared<Resource>();
    auto sptr2 = sptr1->GetSPtr();
    return 0;
}

shared_ptr的循环引用问题：

shared_ptr的引用计数也导致了一个新的问题，就是循环引用，这在把shared_ptr作为类成员的时候最容易出现，典型的例子就是链表节点

#include <iostream>
#include <memory>

class Node {
public:
    using this_type = Node;
    using shared_type = std::shared_ptr<this_type>;

    Node(const std::string &name) : name(name) {
        std::cout << name << " created\n";
    }

    ~Node() {
        std::cout << name << " destroyed\n";
    }

    std::string name;
    shared_type next; // 使用智能指针来指向下一个节点
};

int main() {
    auto n1 = std::make_shared<Node>("n1");
    auto n2 = std::make_shared<Node>("n2");

    assert(n1.use_count() == 1); // 引用计数为1
    assert(n2.use_count() == 1);

    n1->next = n2; // 两个节点互指,形成了循环引用
    n2->next = n1;

    assert(n1.use_count() == 2); // 引用计数为2
    assert(n2.use_count() == 2); // 无法减到0,无法销毁,导致内存泄漏
    return 0;
}

输出：

n1 created
n2 created

上面的代码中，两个节点指针刚创建时，引用计数是1，但指针互指（即拷贝赋值）之后，引用计数都变成了2

这个时候，shared_ptr意识不到这是一个循环引用，多算了一次计数，后果就是引用计数无法减到0，无法调用析构函数执行delete，最终导致内存泄漏

3）、weak_ptr

weak_ptr是专门为打破循环引用而设计，它实际上不会托管对象，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。在需要的时候，可以调用weak_ptr的成员函数lock()，获取shared_ptr（强引用）

#include <iostream>
#include <memory>

class Node {
public:
    using this_type = Node;
    using shared_type = std::weak_ptr<this_type>; // 注意这里,别名改用weak_ptr

    Node(const std::string &name) : name(name) {
        std::cout << name << " created\n";
    }

    ~Node() {
        std::cout << name << " destroyed\n";
    }

    std::string name;
    shared_type next;
};

int main() {
    auto n1 = std::make_shared<Node>("n1");
    auto n2 = std::make_shared<Node>("n2");

    n1->next = n2; // 两个节点互指,形成了循环引用
    n2->next = n1;

    assert(n1.use_count() == 1); // 因为使用了weak_ptr,引用计数为1
    assert(n2.use_count() == 1); // 打破循环引用,不会导致内存泄漏

    if (!n1->next.expired()) { // 检查指针是否有效
        auto ptr = n1->next.lock(); // lock()获取shared_ptr
        assert(ptr == n2);
    }
    return 0;
}

输出：

n1 created
n2 created
n2 destroyed
n1 destroyed
4）、小结

unique_ptr是一种独占资源所有权的指针，它会在栈上分配，然后在离开作用域之后进行释放，删除里面持有的对象，它只能使用move语义转移对象。所以如果你想操作一个指针，在进入作用域的时候分配好内存，然后在离开作用域的时候安全释放对象，那么可以使用它

shared_ptr所管理的资源可以被多个对象持有，并且使用引用计数策略来释放对象，如果计数没有清零，那么它所管理的资源不会释放

weak_ptr不管理对象，只是shared_ptr对象管理的资源的观察者，所以它不影响共享资源的生命周期，它用于解决shared_ptr循环引用

3、lambda表达式

1）、lambda基本使用
#include <iostream>

int main() {
    auto func = [](int x) // 定义一个lambda表达式
    {
        std::cout << x * x << std::endl; // lambda表达式的具体内容
    };
    func(3); // 调用lambda表达式
    return 0;
}

C++里的lambda表达式除了可以像普通函数那样被调用，还有一个普通函数所不具备的特殊本领，就是可以捕获外部变量，在内部的代码里直接操作

#include <iostream>

int main() {
    int n = 10; // 一个外部变量
    auto func = [=](int x) // lambda表达式，用=捕获
    {
        std::cout << x * n << std::endl; // 直接操作外部变量
    };
    func(3); // 调用lambda表达式
    return 0;
}
2）、使用lambda的注意事项

1）lambda的形式

嵌套定义lambda表达式

#include <iostream>

int main() {
    auto f1 = []() // 定义一个lambda表达式
    {
        std::cout << "lambda f1" << std::endl;

        auto f2 = [](int x) // 嵌套定义lambda表达式
        {
            return x * x;
        }; // lambda f2

        std::cout << f2(10) << std::endl;
    }; // lambda f1
    
    f1();
    return 0;
}

匿名lambda表达式

#include <iostream>

int main() {
    std::vector<int> v = {3, 1, 8, 5, 0}; // 标准容器

    std::cout << *find_if(begin(v), end(v), // 标准库里的查找算法
                          [](int x) // 匿名lambda表达式,不需要auto赋值
                          {
                              return x >= 5; // 用做算法的谓词判断条件
                          }
    )
              << std::endl; // 语句执行完,lambda表达式就不存在了
    return 0;
}

2）lambda的变量捕获

lambda的变量捕获要点：

  • [=]：表示按值捕获所有外部变量，表达式内部是值的拷贝，并且不能修改
  • [&]：按引用捕获所有外部变量，内部以引用的方式使用，可以修改
  • 可以在[]里明确写出外部变量名，指定按值或者按引用捕获
int main() {
    int x = 33; // 一个外部变量
    auto f1 = [=]() // lambda表达式,用=按值捕获
    {
        //x += 10; // x只读,不允许修改
    };
    auto f2 = [&]() // lambda表达式,用&按引用捕获
    {
        x += 10; // x是引用,可以修改
    };
    auto f3 = [=, &x]() // lambda表达式,用&按引用捕获x,其他的按值捕获
    {
        x += 20; // x是引用,可以修改
    };
    return 0;
}

3）泛型的lambda

在C++14里，lambda表达式可以实现泛型化，相当于简化了的模板函数

#include <iostream>

int main() {
    auto f = [](const auto &x) // 参数使用auto声明,泛型化
    {
        return x + x;
    };
    std::cout << f(3) << std::endl; // 参数类型是int
    std::cout << f(0.618) << std::endl; // 参数类型是double

    std::string str = "matrix";
    std::cout << f(str) << std::endl; // 参数类型是string
    return 0;
}
3）、小结
  1. lambda表达式是一个闭包，能够像函数一样被调用，像变量一样被传递
  2. 可以使用auto自动推导类型存储lambda表达式，但C++鼓励尽量就地匿名使用，缩小作用域
  3. lambda表达式使用[=]的方式按值捕获，使用[&]的方式按引用捕获，空的[]则是无捕获（也就相当于普通函数）
  4. 捕获引用时必须要注意外部变量的生命周期，防止变量失效
  5. C++14里可以使用泛型的lambda表达式，相当于简化的模板函数

参考：

07 | const/volatile/mutable：常量/变量究竟是怎么回事？

C++ 中让人头晕的const & constexpr

08 | smart_ptr：智能指针到底“智能”在哪里？

写给[C++ ]新人智能指针避坑指南

10 | lambda：函数式编程带来了什么？

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/777165.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

深度卷积神经网络 AlexNet

深度卷积神经网络 AlexNet

一、机器学习深度学习的发展 1、机器学习SVM方法 &#xff08;1&#xff09;20世纪90年代&#xff0c;基于统计学习理论的结果&#xff0c;开发了一种新型的学习算法——支持向量机&#xff08;SVM&#xff09;。这就产生了一类新的理论上优雅的学习机器&#xff0c;它们将SVM…
阅读更多...
大厂面试官问我：MySQL宕机重启了，怎么知道哪些事务是需要回滚的哪些是需要提交的？【后端八股文九：Mysql事务八股文合集】

大厂面试官问我：MySQL宕机重启了，怎么知道哪些事务是需要回滚的哪些是需要提交的？【后端八股文九：Mysql事务八股文合集】

本文为【Mysql事务八股文合集】初版&#xff0c;后续还会进行优化更新&#xff0c;欢迎大家关注交流~ 大家第一眼看到这个标题&#xff0c;不知道心中是否有答案了&#xff1f;在面试当中&#xff0c;面试官经常对项目亮点进行深挖&#xff0c;来考察你对这个项目亮点的理解以及…
阅读更多...
2024/7/6 英语每日一段

2024/7/6 英语每日一段

More than half of late-teens are specifically calling for more youth work that offers “fun”, with older teenagers particularly hankering for more jollity, according to a study carried out by the National Youth Agency. One in 10 said they have zero option…
阅读更多...
vite+vue3整合less教程

vite+vue3整合less教程

1、安装依赖 pnpm install -D less less-loader2、定义全局css变量文件 src/assets/css/global.less :root {--public_background_font_Color: red;--publicHouver_background_Color: #fff;--header_background_Color: #fff;--menu_background: #fff; }3、引入less src/main.…
阅读更多...
罗剑锋的C++实战笔记学习（二）：容器、算法库、多线程

罗剑锋的C++实战笔记学习（二）：容器、算法库、多线程

4、容器 1&#xff09;、容器的通用特性 所有容器都具有的一个基本特性&#xff1a;它保存元素采用的是值&#xff08;value&#xff09;语义&#xff0c;也就是说&#xff0c;容器里存储的是元素的拷贝、副本&#xff0c;而不是引用 容器操作元素的很大一块成本就是值的拷贝…
阅读更多...
重大更新来袭！！《植物大战僵尸杂交版V2.1+修改器+融合版》

重大更新来袭！！《植物大战僵尸杂交版V2.1+修改器+融合版》

大家好&#xff01;每个软件更新总是令人兴奋不已。前段时间介绍的《植物大战僵尸》系列以其独特的策略玩法和丰富的植物角色&#xff0c;赢得了很多玩家的喜爱。而在今天&#xff0c;这款经典游戏全网最新版本——《植物大战僵尸&#xff1a;杂交版V2.1》正式推出&#xff0c;…
阅读更多...
【Mindspore进阶】实战ResNet50图像分类

【Mindspore进阶】实战ResNet50图像分类

ResNet50图像分类 图像分类是最基础的计算机视觉应用&#xff0c;属于有监督学习类别&#xff0c;如给定一张图像(猫、狗、飞机、汽车等等)&#xff0c;判断图像所属的类别。本章将介绍使用ResNet50网络对CIFAR-10数据集进行分类。 ResNet网络介绍 ResNet50网络是2015年由微…
阅读更多...
vue require引入静态文件报错

vue require引入静态文件报错

如果是通过向后端发送请求&#xff0c;动态的获取对应的文件数据流很容易做到文件的显示和加载。现在研究&#xff0c;一些不存放在后端而直接存放在vue前端项目中的静态媒体文件如何加载。 通常情况下&#xff0c;vue项目的图片jpg&#xff0c;png等都可以直接在/ass…
阅读更多...
量化机器人：金融市场的智能助手

量化机器人：金融市场的智能助手

引言 想象一下&#xff0c;在繁忙的金融市场中&#xff0c;有一位不知疲倦、冷静客观的“超级交易员”&#xff0c;它能够迅速分析海量数据&#xff0c;精准捕捉交易机会&#xff0c;并自动完成买卖操作。这位“超级交易员”不是人类&#xff0c;而是我们今天要聊的主角——量…
阅读更多...
Qt5.9.9 关于界面拖动导致QModbusRTU(QModbusTCP没有测试过)离线的问题

Qt5.9.9 关于界面拖动导致QModbusRTU(QModbusTCP没有测试过)离线的问题

问题锁定 参考网友的思路&#xff1a; Qt5.9 Modbus request timeout 0x5异常解决 网友认为是Qt的bug&#xff0c; 我也认同&#xff1b;网友认为可以更新模块&#xff0c; 我也认同&#xff0c; 我也编译了Qt5.15.0的code并成功安装到Qt5.9.9中进行使用&#xff0c;界面拖…
阅读更多...
从CPU的视角看C++的构造函数和this指针

从CPU的视角看C++的构造函数和this指针

从汇编角度&#xff0c;清晰的去看构造函数和this指针到底是个什么东西呢&#xff1f;也许可以解决你的一点小疑问 首先写一个很简单的代码demo&#xff1a; class A{ public:int a;A(){;}void seta(int _a){a_a;}A* getA(){return this;} };int fun1(int px){return px; }in…
阅读更多...
全新桌面编辑器

全新桌面编辑器

目录 前言 一、链接 ONLYOFFICE 8.1版本 官网下载链接&#xff1a; ONLYOFFICE 在线工具&#xff1a; 下载版本推荐&#xff1a; 二、使用体验 1. 界面设计&#xff1a; 2. 文档编辑功能&#xff1a; 3. 电子表格功能&#xff1a; 4. 演示文稿功能&#xff1a; 5.PDF编…
阅读更多...
python-开关灯（赛氪OJ）

python-开关灯（赛氪OJ）

[题目描述] 假设有 N 盏灯&#xff08;N 为不大于 5000 的正整数&#xff09;&#xff0c;从 1 到到 N 按顺序依次编号&#xff0c;初始时全部处于开启状态&#xff1b;第一个人&#xff08; 1 号&#xff09;将灯全部关闭&#xff0c;第二个人&#xff08; 2 号&#xff09;将…
阅读更多...
nginx修改网站默认根目录及发布（linux、centos、ubuntu）openEuler软件源repo站点

nginx修改网站默认根目录及发布（linux、centos、ubuntu）openEuler软件源repo站点

目录 安装nginx配置nginx其它权限配置 安装nginx dnf install -y nginx配置nginx whereis nginxcd /etc/nginx llcd conf.d touch vhost.conf vim vhost.conf 命令模式下输入:set nu或:set number可以显示行号 复制如下内容&#xff1a; server {listen 80;server_name…
阅读更多...
基于java+springboot+vue实现的流浪动物管理系统（文末源码+Lw）277

基于java+springboot+vue实现的流浪动物管理系统（文末源码+Lw）277

摘 要 在如今社会上&#xff0c;关于信息上面的处理&#xff0c;没有任何一个企业或者个人会忽视&#xff0c;如何让信息急速传递&#xff0c;并且归档储存查询&#xff0c;采用之前的纸张记录模式已经不符合当前使用要求了。所以&#xff0c;对流浪动物信息管理的提升&…
阅读更多...
玩转Easysearch语法

玩转Easysearch语法

Elasticsearch 是一个基于Apache Lucene的开源分布式搜索和分析引擎&#xff0c;广泛应用于全文搜索、结构化搜索、分析等多种场景。 Easysearch 作为Elasticsearch 的国产化替代方案&#xff0c;不仅保持了与原生Elasticsearch 的高度兼容性&#xff0c;还在功能、性能、稳定性…
阅读更多...
Spring框架Mvc（2）

Spring框架Mvc（2）

1.传递数组 代码示例 结果 2.集合参数存储并进行存储类似集合类 代码示例 postman进行测试 &#xff0c;测试结果 3.用Json来对其进行数据的传递 &#xff08;1&#xff09;Json是一个经常使用的用来表示对象的字符串 &#xff08;2&#xff09;Json字符串在字符串和对象…
阅读更多...
Mysql数据库索引、事务相关知识

Mysql数据库索引、事务相关知识

索引 索引是一种特殊的文件&#xff0c;包含着对数据表里所有记录的引用指针。可以对表中的一列或多列创建索引&#xff0c; 并指定索引的类型&#xff0c;各类索引有各自的数据结构实现 查看索引 show index from 表名;创建索引对于非主键、非唯一约束、非外键的字段&#…
阅读更多...
JAVA ArrayList应用案例

JAVA ArrayList应用案例

一案例要求&#xff1a; 二代码&#xff1a; package 重修;import java.util.ArrayList; import java.util.Random; import java.util.Scanner;public class first {public static void main(String[] args) {ArrayList<String>arrayListnew ArrayList<>();array…
阅读更多...
ctfshow-web入门-文件包含（web87）巧用 php://filter 流绕过死亡函数的三种方法

ctfshow-web入门-文件包含（web87）巧用 php://filter 流绕过死亡函数的三种方法

目录 方法1&#xff1a;php://filter 流的 base64-decode 方法 方法2&#xff1a;通过 rot13 编码实现绕过 方法3&#xff1a;通过 strip_tags 函数去除 XML 标签 除了替换&#xff0c;新增 file_put_contents 函数&#xff0c;将会往 $file 里写入 <?php die(大佬别秀了…
阅读更多...
最新文章

Copyright @ 2022~2023