C++相关闲碎记录(1)

news2024/11/24 20:47:27

1、C++绘制爱心图像

#include <iostream>
#include <cmath>

using namespace std;

int main() {
    // 心形曲线公式 (x^2 + y^2 - a)^3 - x^2*y^3 = 0
    double a = 1;
    double bound = 1.5 * sqrt(a);
    double step = 0.05;
    for (double y = bound; y >= -bound; y -= step) {
        for (double x = -bound; x <=  bound; x += 0.5*step) {
            double result = pow((pow(x,2) + pow(y, 2) - a), 3) - pow(x,2) * pow(y, 3);
            if(result <= 0) {
                cout << "*";
            } else {
                cout << " ";
            }
        }
        cout << "\n";
    }
    return 0;
}

2、旋转矩阵90°

#include <iostream>
#include <cmath>

using namespace std;

int main() {
    // 矩阵旋转
    const int n = 4;
    int image[n][n] = {
        {5, 1, 8, 11},
        {2, 4, 8, 10},
        {13, 3, 6, 7},
        {15, 14, 12, 16}
    };
    // 矩阵转置
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            swap(image[i][j], image[j][i]);
        }
    }
    // 行内翻转
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n/2; j++) {
            swap(image[i][j], image[i][n-j-1]);
        }
    }
    // 输出
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << image[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

3、std::initializer_list<int>

#include <iostream>

using namespace std;

class P {
public:
    P(int, int) {std::cout << "(int, int)" << std::endl;}
    P(std::initializer_list<int>) {
        std::cout << "(std::initializer_list<int>)" << std::endl;
    }
};

int main(int argc, char* argv[]) {
    P p1(77, 5);
    P p2{77, 5};
    P r{77, 5, 42};
    P s = {77, 5};
    return 0;
}

输出
(int, int)
(std::initializer_list<int>)
(std::initializer_list<int>)
(std::initializer_list<int>)

#include <iostream>

using namespace std;

class P {
public:
    P(int, int) {std::cout << "(int, int)" << std::endl;}
    // P(std::initializer_list<int>) {
    //     std::cout << "(std::initializer_list<int>)" << std::endl;
    // }
};

int main(int argc, char* argv[]) {
    P p1(77, 5);
    P p2{77, 5};
    // P r{77, 5, 42};
    P s = {77, 5};
    return 0;
}
输出：
(int, int)
(int, int)
(int, int)

4、template

#include <iostream>

using namespace std;

void print() {}

template<typename T, typename... Type>
void print(const T& firstArgs, const Type&... args) {
    std::cout << firstArgs << std::endl;
    print(args...);
}

int main(int argc, char* argv[]) {
    print("aaaa", 1, "fefefe", 1.3, 'a');
    return 0;
}

输出：
aaaa
1
fefefe
1.3
a

下面的代码也可以：
#include <iostream>

using namespace std;

template <typename T>
void print(const T& arg) {
    std::cout << arg << std::endl;
}

template<typename T, typename... Type>
void print(const T& firstArgs, const Type&... args) {
    std::cout << firstArgs << std::endl;
    print(args...);
}

int main(int argc, char* argv[]) {
    print("aaaa", 1, "fefefe", 1.3, 'a');
    return 0;
}

5、lambda表达式

int main(int argc, char* argv[]) {
    int x = 0, y = 32;
    auto qqq = [x, &y]() {
        std::cout << "x: " << x << std::endl;
        std::cout << "y: " << y << std::endl;
        ++y;
    };
    x = y = 77;  //这一步y会跟新到lambda中y，但是x不会
    qqq();
    qqq();
    std::cout << "final y: " << y << std::endl; 
    return 0;
}
输出：
x: 0
y: 77
x: 0
y: 78
final y: 79
#include <iostream>
#include <functional>

using namespace std;

std::function<int(int,int)> returnLambda() {
    return [](int x, int y) {
        return x*y;
    };
}
int main(int argc, char* argv[]) {
    auto f = returnLambda();
    std::cout << f(6, 7) << std::endl;
    return 0;
}
输出：42

6、算法

You are given numbers, an array of non-negative integers. Your task is to perform the following algorithm on this array:
        step 1. Find the index i of the leftmost non-zero element numbers[i] = x != 0, if there is no         such element, finish the algorithm.
        step 2. Starting at index i and going to eht right, attemp to subtract x from each element.
                if the element is strictly less than x, move on to step 3;
                Otherwise, subtract x from the element and move on to the next element;
                if you reach the end of the array, move on to the step 3;
        step 3. Add x to the final result.
        step 4. Go back to step 1.

import random

def algo(num_list, x):
    if x <= 0:
        return 0
    final_result = 0
    flag_find_leftmost_x = False
    # 记录那些将来会被找到的num_list[i] = x的下标
    record_list = []
    # 向下传递的减法操作的次数
    op_times = 0
    for i, n in enumerate(num_list):
        # 找到leftmost 等于x
        if num_list[i] == x and not flag_find_leftmost_x:
            flag_find_leftmost_x = True
            record_list.append([i, 0])
            op_times = 1
            continue
        # 表示减法在这里传递失败，更新可以向下传递的次数
        if flag_find_leftmost_x and n - op_times * x <= 0:
            op_times = n // x
            # 如果上次记录的x的后面还没有出现一个小于x的，则标记为出现，在这个题里面record_list中的元素的第二个数字并没有实际用到，
            # 但是如果题目稍作更改，则第二维度的数字就可以排上用场了
            if record_list[-1][1] == 0:
                record_list[-1][1] = 1
        # 减完之后还能够等于x，则这个位置就是下一轮能够找到的num_list[i] = x的位置
        elif flag_find_leftmost_x and n - op_times * x == x:
            op_times += 1
            record_list.append([i, 0])
    # 没有找到x,则返回0
    if not flag_find_leftmost_x:
        return final_result
    # print(record_list)
    total_len = len(record_list)
    final_result = total_len * x
    return final_result


# 最原始的方法
def algo_complexity(num_list, x):
    if x <= 0:
        return 0
    total_len = len(num_list)
    i = 0
    final_result = 0
    # print(num_list)
    while i < total_len:
        if num_list[i] == x:
            flag = False
            for j in range(i, total_len):
                if num_list[j] >= x:
                    num_list[j] -= x
                else:
                    final_result += x
                    i = -1
                    flag = True
                    break
            if not flag:
                final_result += x
            # print(num_list)
        i += 1

    return final_result


# num_list = [1, 2, 1, 3, 4, 2, 4, 6]
# num_list = [1, 2, 1, 1, 3, 4, 2, 3, 4, 6]
# num_list = [1, 2, 3, 1, 1, 3, 4, 2, 3, 4, 6]

# num_list = [1, 2, 3, 4, 1, 3, 4, 2, 3, 4, 6]
# num_list = [1, 0, 1, 2, 1, 3, 4, 2, 3, 4, 6]  # 2
# num_list = [1, 0, 1, 0, 1, 3, 4, 2, 3, 4, 6]  # 2 + 2
# num_list = [1, 0, 1, 0, 1, 3, 4, 0, 1, 2, 4]  # 2 + 2 + 2
# num_list = [1, 0, 1, 0, 1, 3, 4, 0, 1, 0, 2]  # 2 + 2 + 2 + 2
# num_list = [1, 0, 1, 0, 1, 3, 4, 0, 1, 0, 0]  # 2 + 2 + 2 + 2 + 2

# print(algo(num_list, 20))
# print(algo_complexity(num_list.copy(), 20))


# 进行10000次测试
for i in range(10000):
    # 随机生成测试列表的长度
    list_len = random.randint(6, 500)
    # 随机生成列表
    num_list = [random.randint(1, 100) for j in range(list_len)]
    x = random.randint(1,100)
    # print("output1: ", algo(num_list, x))
    # print("output2: ", algo_complexity(num_list, x))
    a1 = algo(num_list, x)
    a2 = algo_complexity(num_list.copy(), x)
    if a1 != a2:
        print(a1, ",", a2)
        print(num_list)
        print(x)

print("finished")

7、C++解析CSV文件到vector中

CSV文件格式：a,b,c
#include <iostream>
#include <string>
#include <fstream>
#include <vector>

vector<double> getFileData(char* fileName) {
    vector<double> res;
    ifstream is(fileName);
    if (!is) {
        return res;
    }
    string temp;
    const char* split = ",";
    while(getline(is, temp)) {
        char* line = (char*)temp.c_str();
        char* data = strtok(line, split);
        whlie(data!=NULL) {
            res.push_back(atof(data));
            data = strtok(NULL, split);
        }
    }
    is.close();
    return res;
}

8、C++异常体系

异常类定义于许多头文件中，为了能够处理标准库可能抛出的所有异常，必须包含：

#include <exception>
#include <stdexcept>
#include <system_error>
#include <new>
#include <ios>
#include <future>
#include <typeinfo>

9、bind()， async()的使用

#include <iostream>
#include <functional>
#include <memory>
#include <future>
using namespace std;

void func(int x, int y) {
    std::cout << "func" << std::endl;
}

auto l = [](int x, int y) {
    std::cout << "lambda l" << std::endl;
};

class C {
public:
    void operator() (int x, int y) const {
        std::cout << "class C operator" << std::endl;
    }
    void memfunc(int x, int y) const {
        std::cout << "memfunc" << std::endl;
    }
};



int main(int argc, char* argv[]) {
    C c;
    std::shared_ptr<C> sp(new C);

    // bind()
    std::bind(func, 22, 22)();                  // calls func(22, 22)
    std::bind(l, 22, 33)();                     // calls l(22, 33)
    std::bind(C(), 33, 333)();                  // calls C::operator()(33, 333)
    std::bind(&C::memfunc, c, 22, 33)();        // calls c.memfunc(22, 33)
    std::bind(&C::memfunc, sp, 33, 33)();       // calls sp->memfunc(33, 33)

    // async()
    std::async(func, 23, 43);                   // calls func(22, 43)
    std::async(l, 112, 32);                     // calls l(112, 32)
    std::async(c, 23, 32);                      // calls c.operator()(23, 32)
    std::async(&C::memfunc, &c, 23, 23);        // calls c.memfunc(23, 23)
    std::async(&C::memfunc, sp, 23, 23);        // calls sp->memfunc(42, 77)
    return 0;
}


typedef std::pair<int, float> IntFloatPair;
IntFloatPair p(42, 3.14);
std::get<0>(p);
std::get<1>(p);
std::tuple_size<IntFloatPair>::value;
std::tuple_element<0, IntFloatPair>::type

10、C++用迭代器删除map元素

int main(int argc, char* argv[]) {
    vector<int> nums{1, 2, 3};
    for (auto it = nums.begin(); it != nums.end(); ) {
        if (*it == 2) {
            it = nums.erase(it);
        } else {
            it++;
        }
    }
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }

    map<int, int> mp{{1, 2}, {3, 4}, {5, 6}};
    for (auto it = mp.begin(); it != mp.end();) {
        if(it->first == 3) {
            it = mp.erase(it);
        } else {
            it++;
        }
    }
    for (auto it = mp.begin(); it != mp.end(); it++) {
        cout << it->first << " " << it->second << endl;
    }
    return 0;
}

11、map和unordered_map底层实现

unordered_map和map的区别，从算法，底层实现原理区别，效率，桶树等结构等等多个层面解析（c++角度）_unordermap和map性能比较-CSDN博客

12、从非常大的数据里面找出出现次数最多的数

经典面试问题: Top K 之 ---- 海量数据找出现次数最多或，不重复的。 - 指尖下的幽灵 - 博客园 (cnblogs.com)

13、connect函数HOOK

14、unique_ptr如何实现独享

C++ 智能指针unique_ptr原理与自定义实现_unique_ptr move_newchenxf的博客-CSDN博客

15、share_ptr是否线程安全？

c++11总结15——shared_ptr在多线程下的安全性问题_shared_ptr多线程-CSDN博客

所以当我们多个线程访问同一个shared_ptr时，应该要进行加锁操作。 

16、线程有哪些数据是独享的

线程的共享资源与独立资源_线程独有的资源-CSDN博客

17、tuple的输出

#include <iostream>
#include <string>
#include <tuple>
using namespace std;

// tuple的输入输出
// helper: print element with index IDX of tuple with MAX elements
template<int IDX, int MAX, typename ...Args>
struct PRINT_TUPLE {
    static void print(std::ostream& strm, const std::tuple<Args...>& t) {
        strm << std::get<IDX>(t) << (IDX+1 == MAX? "": ",");
        PRINT_TUPLE<IDX+1, MAX, Args...>::print(strm, t);
    }
};
// partial specialization to end the recursion
template<int MAX, typename... Args>
struct PRINT_TUPLE<MAX, MAX, Args...>{
    static void print(std::ostream& strm, const std::tuple<Args...>& t) {}
};

// ou
template <typename... Args>
std::ostream& operator<< (std::ostream& strm, const std::tuple<Args...> &t) {
    strm << "[";
    PRINT_TUPLE<0, sizeof...(Args), Args...>::print(strm, t);
    strm << "]";
}

int main(int argc, char* argv[]) {
    std::tuple<int, float, string> t(44, 2.2, "more light");
    std::cout << "io: " << t << endl;
    return 0;
}

18、智能指针删除器

#include <iostream>
#include <string>
#include <tuple>
#include <memory>
using namespace std;

// 自定义智能指针的删除器

int main(int argc, char* argv[]) {
    // 使用lambda函数
    std::shared_ptr<int> p(new int[10], [](int* p) {
        delete []p;
    });
    
    std::shared_ptr<int> p1(new int[10],
        std::default_delete<int[]>());
    
    std::unique_ptr<int[]> p2(new int[10]);  //ok
    std::shared_ptr<int[]> p3(new int[10]);  // error

    // unique_ptr必须明确第二个模板参数，指出自己的deleter
    std::unique_ptr<int, void(*)(int*)> p4(new int[10], 
        [](int* p) {
            delete[] p;
        });
    
    return 0;
}

指向某个文件的最后一个引用销毁时，该文件被移除：

#include <iostream>
#include <string>
#include <fstream>
#include <tuple>
#include <memory>
using namespace std;

// 自定义智能指针的删除器

class FileDeleter {
private:
    std::string filename;
public:
    FileDeleter(const std::string& file):filename(file){}
    void operator() (std::ofstream* fp) {
        fp->close();
        std::remove(filename.c_str());
    }
};

int main(int argc, char* argv[]) {
    std::shared_ptr<std::ofstream> fp(new std::ofstream("tmpfile.txt"), FileDeleter("tmpfile.txt"));
    *fp << "ddd";
    return 0;
}

 使用shared_ptr处理共享内存

linux 共享内存 shm_open ，mmap的正确使用-CSDN博客

#include <iostream>
#include <string>
#include <fstream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <cerrno>
#include <tuple>
#include <memory>
using namespace std;

// 自定义智能指针的删除器
// 使用shared_ptr处理共享内存
class SharedMemoryDetacher {
public:
    void operator()(int* p) {
        std::cout << "unlink /tmp1234" << std::endl;
        if (shm_unlink("/tmp1234") != 0) {
            std::cerr << "OOPS: shm_unlink() failed" << std::endl;
        }
    }
};

std::shared_ptr<int> getSharedIntMemory(int num) {
    void* mem;
    int shmfd = shm_open("/tmp1234", O_CREAT | O_RDWR, S_IRWXU | S_IRWXG);
    if (shmfd < 0) {
        throw std::string(strerror(errno));
    }
    if (ftruncate(shmfd, num*sizeof(int)) == -1) {
        throw std::string(strerror(errno));
    }
    mem = mmap(nullptr, num*sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
    if (mem == MAP_FAILED) {
        throw std::string(strerror(errno));
    }
    return std::shared_ptr<int>(static_cast<int*>(mem), SharedMemoryDetacher());
}

int main(int argc, char* argv[]) {
    std::shared_ptr<int> smp(getSharedIntMemory(100));
    for (int i = 0; i < 100; i++) {
        smp.get()[i] = i*42;
    }
    // deal with shared memory somewhere else

    std::cout << "<return>" << std::endl;
    std::cin.get();

    smp.reset();
    return 0;
}

19、weak_ptr的使用

#include <iostream>
#include <string>
#include <vector>
#include <memory>

using namespace std;

//weak_ptr
class Person {
public:
    string name;
    shared_ptr<Person> mother;
    shared_ptr<Person> father;
    vector<shared_ptr<Person>> kids;

    Person(const string& n, shared_ptr<Person> m = nullptr,
           shared_ptr<Person> f = nullptr) :name(n), mother(m), father(f) {}
        
    ~Person() {
        cout << "delete " << name << endl;
    }
};

shared_ptr<Person> initFamily(const string& name) {
    shared_ptr<Person> mom(new Person(name + "'s mom"));
    shared_ptr<Person> dad(new Person(name + "'s dad"));
    shared_ptr<Person> kid(new Person(name, mom, dad));
    mom->kids.push_back(kid);
    dad->kids.push_back(kid);
    return kid;
}


int main(int argc, char* argv[]) {
    shared_ptr<Person> p = initFamily("nico");
    cout << "nico's family exists" << endl;
    cout << "- nico is shared " << p.use_count() << " times" << endl;
    cout << "- name of 1st kid of nico's mom: "
         << p->mother->kids[0]->name << endl;
    
    // 重新修改p的指向，会发现没有delete函数被调用
    p = initFamily("jim");
    cout << "jim's family exists" << endl;
    return 0;
}



#include <iostream>
#include <string>
#include <vector>
#include <memory>

using namespace std;

//weak_ptr
class Person {
public:
    string name;
    shared_ptr<Person> mother;
    shared_ptr<Person> father;
    vector<weak_ptr<Person>> kids;   //使用weak_ptr

    Person(const string& n, shared_ptr<Person> m = nullptr,
           shared_ptr<Person> f = nullptr) :name(n), mother(m), father(f) {}
        
    ~Person() {
        cout << "delete " << name << endl;
    }
};

shared_ptr<Person> initFamily(const string& name) {
    shared_ptr<Person> mom(new Person(name + "'s mom"));
    shared_ptr<Person> dad(new Person(name + "'s dad"));
    shared_ptr<Person> kid(new Person(name, mom, dad));
    mom->kids.push_back(kid);
    dad->kids.push_back(kid);
    return kid;
}


int main(int argc, char* argv[]) {
    shared_ptr<Person> p = initFamily("nico");
    cout << "nico's family exists" << endl;
    cout << "- nico is shared " << p.use_count() << " times" << endl;
    cout << "- name of 1st kid of nico's mom: "
         << p->mother->kids[0].lock()->name << endl;    //使用weak_ptr时，这里需要修改，因为weak_ptr没有* ->操作符
    
    // 重新修改p的指向，会发现没有delete函数被调用
    p = initFamily("jim");
    cout << "jim's family exists" << endl;
    return 0;
}

输出：
nico's family exists
- nico is shared 1 times
- name of 1st kid of nico's mom: nico
delete nico
delete nico's dad
delete nico's mom
jim's family exists
delete jim
delete jim's dad
delete jim's mom

 如果不确定weak_ptr背后的对象是否存活，可以使用如下三个方法检查weak_ptr

（1）调用expired()，它会在weak_ptr不再共享对象时，返回true，等同于检查use_count()是否为0.

（2）使用响应的shared_ptr构造函数明确的将weak_ptr转换为一个shared_ptr，如果对象不存在，构造函数会抛出异常bad_weak_ptr异常，其what()会产生bad_weak_ptr。

（3）调用use_count()，询问相应对象拥有者的数量，返回0表示不存在任何有效对象。

try {
    shared_ptr<string> sp(new string("hi"));
    weak_ptr<string> wp = sp;
    sp.reset();
    cout << wp.use_count() << endl;  // 0
    cout << boolalpha << wp.expired() << endl; // true
    shared_ptr<string> p(wp); // bad_weak_ptr

} catch (const std::exception& e) {
    cerr << "exception: " << e.what() << endl;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

vue或uniapp中keep-alive的使用，（附带生命周期原理图）

vue或uniapp中keep-alive的使用，（附带生命周期原理图）

什么是keep-alive&#xff1f; keep-alive是一个内置组件&#xff0c;用于缓存和管理组件的状态。 当 keep-alive包裹一个组件时&#xff0c;这个组件的状态将会被缓存起来&#xff0c;而不是每次重新渲染。这在多个视图之间切换时特别有用&#xff0c;可以避免重复的创建和销…
阅读更多...
【Spring】Spring是什么？

【Spring】Spring是什么？

文章目录 前言什么是Spring什么是容器什么是 IoC传统程序开发控制反转式程序开发理解Spring IoCDI Spring帮助网站 前言 前面我们学习了 servlet 的相关知识&#xff0c;但是呢&#xff1f;使用 servlet 进行网站的开发步骤还是比较麻烦的&#xff0c;而我们本身程序员就属于是…
阅读更多...
leetcode:2864. 最大二进制奇数（python3解法）

leetcode:2864. 最大二进制奇数（python3解法）

难度&#xff1a;简单 给你一个 二进制 字符串 s &#xff0c;其中至少包含一个 1 。 你必须按某种方式 重新排列 字符串中的位&#xff0c;使得到的二进制数字是可以由该组合生成的 最大二进制奇数 。 以字符串形式&#xff0c;表示并返回可以由给定组合生成的最大二进制奇数。…
阅读更多...
什么是闭包和作用域链？

什么是闭包和作用域链？

1. 什么是闭包 闭包指的是那些引用了另一个函数作用域中变量的函数&#xff0c;通常是在嵌套函数中实现的。 举个栗子&#xff0c;createCounter 接受一个参数 n&#xff0c;然后返回一个匿名函数&#xff0c;这个匿名函数是闭包&#xff0c;它可以访问外部函数 createCounte…
阅读更多...
Centos7上面部署redis

Centos7上面部署redis

Centos7上面部署redis 编写这个部署redis&#xff0c;只是为了另一个文章入侵redis做准备&#xff0c;网上还有好多类似的文章&#xff0c;这个单纯的就是部署安装&#xff0c;并简单的测试使用以下 关联其他文章 [1]VMware上面安装部署centos7镜像系统【详细含镜像】 [2]血的教…
阅读更多...
多集群部署中的 Kubernetes 弹性 (RTO/RPO)

多集群部署中的 Kubernetes 弹性 (RTO/RPO)

啊&#xff0c;Kubernetes&#xff01;我们DevOps挑战的万灵药。 Kubernetes是一个开源的容器编排工具&#xff0c;本应加速软件交付、保护我们的应用程序、降低成本并减少我们的头痛问题&#xff0c;对吗&#xff1f; 不过说真的&#xff0c;Kubernetes已经彻底改变了我们编…
阅读更多...
kali系统复现环境：Vulfocus 提示服务器内部错误，请联系管理员的解决方法

kali系统复现环境：Vulfocus 提示服务器内部错误，请联系管理员的解决方法

Linux-kali系统复现环境&#xff1a;Vulfocus&&提示服务器内部错误&#xff0c;请练习管理员的解决方法 第一步&#xff1a; 先下载docker和docker-compose apt-get update apt-get install docker apt-get install docker-compose输入如下图命令&#xff0c;有版本…
阅读更多...
HarmonyOS应用开发者基础认证【题库答案】

HarmonyOS应用开发者基础认证【题库答案】

HarmonyOS应用开发者高级认证【题库答案】 一、判断 首选项preferences是以Key-Value形式存储数据&#xff0c;其中Key是可以重复。&#xff08;错&#xff09;使用http模块发起网络请求时&#xff0c;必须要使用on(‘headersReceive’&#xff09;订阅请求头&#xff0c;请…
阅读更多...
恒温恒湿试验设备故障维修指南

恒温恒湿试验设备故障维修指南

恒温恒湿试验设备是一种用于模拟特定温度和湿度条件下的环境的设备&#xff0c;通常用于测试产品在不同环境条件下的性能。设备可能会出现故障&#xff0c;导致温湿度控制不准确或其他问题。以下是一般的故障排除和维修指南&#xff0c;但请注意&#xff0c;具体的维修步骤可能…
阅读更多...
01:编译lua及C调用

01:编译lua及C调用

我们今天在windows平台编译lua&#xff0c;生成 lua动态库,lua.exe&#xff0c;luac.exe 我把这个目录上传到giee&#xff0c;使用下面命令获取它: git clone gitgitee.com:jameschenbo/lua_c_application.git 或者直接访问:访问网页 目录结构如下&#xff1a; build.cmd 是…
阅读更多...
美女骑士开箱VELO Angel TT，银色天使，无痛骑行

美女骑士开箱VELO Angel TT，银色天使，无痛骑行

阳光、女孩、自行车&#xff0c;脸上的笑容或明媚&#xff0c;或神秘&#xff0c;或青涩&#xff0c;在这个时候&#xff0c;世界上没有什么比骑行女孩更美的了&#xff01; 　　 　　在北京&#xff0c;有一个热爱骑行的女孩&#xff0c;名叫季思铭&#xff0c;目前是中国农业…
阅读更多...
开发测试利器之Fiddler网络调试工具详细安装使用教程(包含汉化脚本)

开发测试利器之Fiddler网络调试工具详细安装使用教程(包含汉化脚本)

一、Fiddler简介 Fiddler 是一款功能强大的网络调试工具&#xff0c;可以帮助开发人员和测试人员分析和调试网络流量。它通过截取计算机和服务器之间的HTTP/HTTPS请求&#xff0c;并提供详细的请求和响应信息来帮助我们理解和诊断网络通信。 Fiddler 可以用于各种用途&#x…
阅读更多...
案例说法：智能网联车背后的安全隐患

案例说法：智能网联车背后的安全隐患

随着汽车智能化、网联化的发展&#xff0c;汽车数据处理能力日益增强&#xff0c;未经授权对个人信息和重要数据采集、利用等数据安全问题逐步凸显。对车辆网络攻击、网络侵入等网络安全问题恐将危及个人生命安全、合法权益&#xff0c;甚至危害公共利益、国家安全&#xff0c;…
阅读更多...
【活动回顾】sCrypt在柏林B2029开发者周

【活动回顾】sCrypt在柏林B2029开发者周

B2029 是柏林的一个区块链爱好者、艺术家和建设者聚会&#xff0c;学习、讨论和共同构建比特币区块链地方。 在2023年6月9日至11日&#xff0c;举行了第7次Hello Metanet研讨会。本次研讨会旨在为参与者提供一个学习、讨论和共同构建比特币区块链的平台。 在这个充满激情和创意…
阅读更多...
js moment时间范围拿到中间间隔时间

js moment时间范围拿到中间间隔时间

2023.11.27今天我学习了如何对只返回的开始时间和结束时间做处理&#xff0c;比如后端返回了&#xff1a; [time:{start:202301,end:202310}] 我们需要把中间的间隔渲染出来。 [202301,202302,202303,202304,202305,202306,202307,202308,202309,202310] 利用moment的add进…
阅读更多...
图解算法数据结构-LeetBook-树03_层序遍历奇数偶数行方向不同

图解算法数据结构-LeetBook-树03_层序遍历奇数偶数行方向不同

一棵圣诞树记作根节点为 root 的二叉树&#xff0c;节点值为该位置装饰彩灯的颜色编号。请按照如下规则记录彩灯装饰结果&#xff1a; 第一层按照从左到右的顺序记录 除第一层外每一层的记录顺序均与上一层相反。即第一层为从左到右&#xff0c;第二层为从右到左。 示例 1&…
阅读更多...
需要更改你的Apple ID吗？你可以在iPhone上管理它！一文教你如何更改Apple ID

需要更改你的Apple ID吗？你可以在iPhone上管理它！一文教你如何更改Apple ID

你的iCloud帐户用于将你的数据存储在苹果的云存储服务中。它还连接到你的Apple ID，该ID用于使用iPhone和iPad进行在线购买。更改你的联系信息、发货地址和Apple ID密码很容易。 如何在iPhone和iPad上更改你的Apple ID联系信息 你可以在iPhone或iPad上更改你的姓名、电子邮件…
阅读更多...
【数据库】MongoDB 简介：一种文档数据库

【数据库】MongoDB 简介：一种文档数据库

MongoDB 简介&#xff1a;一种文档数据库 1.MongoDB 介绍2.MongoDB 数据存储方式3.MongoDB 概念与操作3.1 Create Operations3.2 Read Operations3.3 Update Operations3.4 Delete Operations 4.MongoDB 特点5.MongoDB 应用场景 1.MongoDB 介绍 MongoDB 是一个基于分布式文件存…
阅读更多...
Node——Node.js简介

Node——Node.js简介

Node.js是一个基于Chrome V8引擎的JavaScript运行时环境&#xff0c;它能够让JavaScript脚本运行在服务端&#xff0c;这使得JavaScript成为与PHP、Python等服务端语言平起平坐的脚本语言。 1、认识Node.js Node.js是当今网站开发中非常流行的一种技术&#xff0c;它以简单易…
阅读更多...
Eureka简单使用做微服务模块之间动态请求

Eureka简单使用做微服务模块之间动态请求

创建一个eureka模块,引入eureka 为启动项加上EnableEurekaServer注解 配置信息 orderService和userService的操作是一样的 这里以orderService为例: 引入eureka客户端 加上 LoadBalanced注解 配置 orderService和userService都配置好了之后 启动 这样我们在http://localhos…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023