C++进制转换（dl）

最新推荐文章于 2024-04-22 15:24:17 发布
最新推荐文章于 2024-04-22 15:24:17 发布
阅读量180 收藏
点赞数
分类专栏： 数据结构 文章标签： c++ java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzh824359508/article/details/120260826
版权

这里写目录标题

进制转换

class Solution {
public:
    /**
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
     string solve(int M, int N) {
        // write code here
        if(M == 0) return "0";//如果M=0就直接返回
        bool flag = false;//记录是不是负数
        if(M < 0){
            //如果是负数flag=true，M 取相反数
            flag = true;
            M = -M;
        }
        string res = "";//返回最终的结果
        string jz = "0123456789ABCDEF";//对应进制的某一位
        while(M != 0){//就对应转换为N进制的逆序样子
            res += jz[M % N];
            M /= N;
        }
        reverse(res.begin(),res.end());//逆序一下才是对应的N进制
        if(flag) res.insert(0,"-");//如果是负数就在头位置插入一个-号
        return res;
    }
};

手撕个环形队列

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;

template<typename T>
class MyQueue2 {
public:
	MyQueue2(int _capacity = 10);
	MyQueue2(const MyQueue2<T>& que);
	MyQueue2<T>& operator=(const MyQueue2<T>& que);
	~MyQueue2();

	void push(T val);
	void pop();
	int size();
	int capcity();
	bool empty();
	T front();
	T back();
private:
	T* queue;
	int front_index;
	int back_index;
	int capacity;
	int qsize;
};

template<typename T>
MyQueue2<T>::MyQueue2(int _capacity) :front_index(0),back_index(0),capacity(_capacity){
	this->queue = new T[_capacity];
	assert(this->queue != nullptr);
}
template<typename T>
MyQueue2<T>::MyQueue2(const MyQueue2<T>& que):front_index(que.front_index),back_index(que.back_index),capacity(que.capacity) {
	this->queue = new T[capacity];
	this->qsize = que.qsize;
	int j = que.front_index;
	for (int i = 0; i < que.qsize; i++) {
		this->queue[i] = que.queue[(j++) % que.capacity];
	}
}
template<typename T>
MyQueue2<T>& MyQueue2<T>::operator=(const MyQueue2<T>& que) {
	if (que != this) {
		delete[] queue;
		this->capacity = que.capacity;
		this->front_index = que.front_index;
		this->back_index = que.back_index;
		this->qsize = que.qsize;
		this->queue = new T[capacity];
		int j = que.front_index;
		for (int i = 0; i < que.qsize; i++) {
			this->queue[i] = que.queue[(j++) % que.capacity];
		}
	}
	return *this;
}
template<typename T>
MyQueue2<T>::~MyQueue2() {
	delete[] this->queue;
}
template<typename T>
void MyQueue2<T>::push(T val) {
	if (this->qsize < this->capacity) {
		this->queue[this->back_index] = val;
		this->back_index = (this->back_index + 1) % this->capacity;
		this->qsize++;
	}
	else {
		T* newqueue = new T[2 * capacity];
		for (int i = 0; i < this->qsize; i++) {
			newqueue[i] = this->queue[(this->front_index++) % this->capacity];
		}
		delete[] this->queue;
		this->queue = newqueue;
		this->front_index = 0;
		this->back_index = this->qsize;
		this->queue[this->back_index] = val;
		this->back_index = (this->back_index + 1) % this->capacity;
		this->qsize++;
		this->capacity *= 2;
	}
}
template<typename T>
void MyQueue2<T>::pop() {
	if (this->qsize != 0) {
		this->front_index = (this->front_index + 1) % this->capacity;
		this->qsize--;
	}
	else
		cout << "empty queue!" << endl;
}
template<typename T>
int MyQueue2<T>::size() {
	return this->qsize;
}
template<typename T>
int MyQueue2<T>::capcity() {
	return this->capacity;
}
template<typename T>
bool MyQueue2<T>::empty() {
	return this->qsize == 0;
}
template<typename T>
T MyQueue2<T>::front() {
	if (this->qsize) {
		return this->queue[this->front_index];
	}
	else {
		cout << "empty queue!" << endl;
	}
}
template<typename T>
T MyQueue2<T>::back() {
	if (this->qsize) {
		return this -> queue[this->back_index - 1];
	}
	else {
		cout << "empty queue!" << endl;
	}
}

手撕大根堆

#pragma once
#include<iostream>
#include<vector>
using namespace std;

class MyBigHeap {
public:
	void push(int val) {
		heap.push_back(val);
		int c = heap.size() - 1;
		int p = (c - 1) / 2;
		while (c > 0) {
			if (heap[c] > heap[p]) {
				swap(heap[c], heap[p]);
				c = p;
				p = (c - 1) / 2;
			}
			else
				break;
		}
	}
	void pop() {
		heap[0] = heap.back();
		heap.pop_back();
		int i = 0, j = i * 2 + 1;
		while (j < heap.size()) {
			if (j < heap.size() - 1 && heap[j] < heap[j + 1]) {
				j++;
			}
			if (heap[i] < heap[j]) {
				swap(heap[i], heap[j]);
				i = j;
				j = 2 * i + 1;
			}
			else
				break;
		}
	}
	int top() {
		return heap[0];
	}
private:
	vector<int> heap;
};

手撕个vector

#pragma once
#include <iostream>
#include <assert.h>
#include<algorithm>
using namespace std;

template<typename T>
class MyVector {
public:
	MyVector(int _vcapacity = 10);
	MyVector(const MyVector<T>& mv);
	MyVector<T>& operator=(const MyVector<T>& mv);
	~MyVector();

	void push_back(T val);
	void pop_back();
	int size();
	int capacity();
	void insert(int index, T val);
	T operator[](int index);
private:
	T* array;
	int vsize;
	int vcapacity;
};

template<typename T>
MyVector<T>::MyVector(int _vcapacity) :vcapacity(_vcapacity), vsize(0) {
	this->array = new T[_vcapacity];
}
template<typename T>
MyVector<T>::MyVector(const MyVector<T>& mv) {
	delete[] this->array;
	this->vcapacity = mv.vcapacity;
	this->vsize = mv.vsize;
	this->array = new T[mv.vcapacity];
	for (int i = 0; i < mv.vsize; i++) {
		this->array[i] = mv.array[i];
	}
}
template<typename T>
MyVector<T>& MyVector<T>::operator=(const MyVector<T>& mv) {
	if (mv != this) {
		delete[] this->array;
		this->vcapacity = mv.vcapacity;
		this->vsize = mv.vsize;
		this->array = new T[mv.vcapacity];
		for (int i = 0; i < mv.vsize; i++) {
			this->array[i] = mv.array[i];
		}
	}
	return *this;
}
template<typename T>
MyVector<T>::~MyVector() {
	delete[] this->array;
}
template<typename T>
void MyVector<T>::push_back(T val) {
	if (this->vsize < vcapacity) {
		this->array[this->vsize] = val;
		this->vsize++;
	}
	else {
		T* newarray = new T[2 * this->vcapacity];
		for (int i = 0; i < this->vsize; i++) {
			newarray[i] = this->array[i];
		}
		delete[] this->array;
		this->array = newarray;
		this->vcapacity = 2 * this->vcapacity;
		array[vsize] = val;
		this->vsize++;
	}
}
template<typename T>
void MyVector<T>::pop_back() {
	this->vsize--;
}
template<typename T>
int MyVector<T>::size() {
	return this->vsize;
}
template<typename T>
int MyVector<T>::capacity() {
	return this->vcapacity;
}
template<typename T>
void MyVector<T>::insert(int index, T val) {
	if (this->vsize == this->vcapacity)
	{
		T* temp = new T[2*this->vcapacity];
		copy(array, array + vcapacity, temp);
		delete[] array;
		this->array = temp;
		this->vcapacity *= 2;
	}
	copy_backward(array + index, array + this->vsize, array + this->vsize + 1);
	this->array[index] = val;
	this->vsize++;
}
template<typename T>
T MyVector<T>::operator[](int index) {
	assert(index < this->vsize);
	return array[index];
}

手撕个memcpy

void memcpy(void *pDst ,void *pSrc ,size_t length)
{
	char *dst=static_cast<char*>(pDst);    //转换成char*
	char *src=static_cast<char*>(pSrc);
	
	if ((src==nullptr)||(dst==nullptr))   //判断是否为野指针
	{
		/* code */
		return;
	}
	
	//分段讨论，判断dst和区间(src,src+length)的位置关系
	//地址不重叠，
	//（1）dst<src，dst在src前面，此时即便dst尾部和src的头部有部分重叠也无所谓，只需要从src的头部复制到尾部即可
	//（2）dst>src+length，只需要从src的头部复制到尾部即可
	if (dst<src || dst>src+length)    
	{
		/* code */
		for (int i = 0; i < length; ++i)
		{
			/* code */
			*dst++=*src++;
		}
	}
	else     //地址重叠，（3）src <= dst <= src+length，此时需要从尾部开始复制
	{
		dst=dst+length-1;   //定位到尾部
		src=src+length-1;
		for (int i = length; i >=0 ; i--)  //从尾部开始复制
		{
			/* code */
			dst[i]=src[i];
		}
	}

}

手撸哈希表（基于容器实现版）

#pragma once
#include<iostream>
#include<vector>
#include<string>
#include<list>
using namespace std;

template<typename T>
class Myhash{
public:
	Myhash():h_size(0), h_capacity(10),hash_array(10) {}
	void insert(T val);
	void print();
	int index(T val);
	void rehash(int _capacity);
	int capacity();
	int size();
private:
	vector<list<int>> hash_array;
	int h_size;
	int h_capacity;
};

template<typename T>
int Myhash<T>::index(T val) {
	return val % this->h_capacity;
}
template<typename T>
void Myhash<T>::insert(T val) {
	int i = this->index(val);
	this->hash_array[i].push_back(val);
	this->h_size++;
	if (this->hash_array[i].size() > 5) {
		this->rehash(this->h_capacity * 2);
	}
}
template<typename T>
void Myhash<T>::rehash(int _capacity) {
	this->h_capacity = _capacity;
	vector<list<T>> temp(_capacity);
	for (auto l : this->hash_array) {
		for (auto n : l) {
			int temp_index = this->index(n);
			temp[temp_index].push_back(n);
		}
	}
	this->hash_array = temp;
}

template<typename T>
void Myhash<T>::print() {
	for (auto l : this->hash_array) {
		for (auto n : l) {
			cout << n << " ";
		}
		cout << endl;
	}
}

template<typename T>
int Myhash<T>::capacity() {
	return this->h_capacity;
}

template<typename T>
int Myhash<T>::size() {
	return this->h_size;
}

#include"hash.h"

int main() {
	Myhash<int> h;
	for (int i = 0; i < 40; i++) {
		h.insert(i);
	}
	h.print();
	cout << "size: " << h.size() << " capacity: " << h.capacity() << endl;
	for (int i = 40; i < 85; i++) {
		h.insert(i);
	}
	h.print();
	cout << "size: " << h.size() << " capacity: " << h.capacity() << endl;
	Myhash<int> h1 = h;
	h.print();
	cout << "size: " << h.size() << " capacity: " << h.capacity() << endl;
	Myhash<int> h2(h);
	h.print();
	cout << "size: " << h.size() << " capacity: " << h.capacity() << endl;
	return 0;
}

手撕share_ptr

#pragma once

template<class T>
class SharedPointer
{
public:
    //默认构造函数，内部指针，未指向任何资源，引用计数为0,因为它未与任何资源绑定
    SharedPointer() :m_refCount(nullptr), m_pointer(nullptr) {}

    //构造函数，初始化时，指向一个已经分配好的资源
    SharedPointer(T* adoptTarget) :m_refCount(nullptr), m_pointer(adoptTarget)
    {
        addReference();
    }

    //构造函数，使用其它对象创建新对象
    SharedPointer(const SharedPointer<T>& copy)
        :m_refCount(copy.m_refCount), m_pointer(copy.m_pointer)
    {
        addReference();
    }

    //析构函数，引用计数递减，当为0时，释放资源
    virtual ~SharedPointer()
    {
        removeReference();
    }

    //赋值操作
    //当左值被赋值时，表明它不再指向所指的资源，故引用计数减一
    //之后，它指向了新的资源，所以对应这个资源的引用计数加一
    SharedPointer<T>& operator=(const SharedPointer<T>& that)
    {
        if (this != &that)
        {
            removeReference();
            this->m_pointer = that.m_pointer;
            this->m_refCount = that.m_refCount;
            addReference();
        }
        return *this;
    }

    //判断是否指向同一个资源
    bool operator==(const SharedPointer<T>& other)
    {
        return m_pointer == other.m_pointer;
    }
    bool operator!=(const SharedPointer<T>& other)
    {
        return !operator==(other);
    }

    //指针解引用
    T& operator*() const
    {
        return *m_pointer;
    }
    //调用所知对象的公共成员
    T* operator->() const
    {
        return m_pointer;
    }

    //获取引用计数个数
    int GetReferenceCount() const
    {
        if (m_refCount)
        {
            return *m_refCount;
        }
        else
        {
            return -1;
        }
    }

protected:
    //当为nullpter时，创建引用计数资源，并初始化为1
    //否则，引用计数加1。
    void addReference()
    {
        if (m_refCount)
        {
            (*m_refCount)++;
        }
        else
        {
            m_refCount = new int(0);
            *m_refCount = 1;
        }
    }

    //引用计数减一，当变为0时，释放所有资源
    void removeReference()
    {
        if (m_refCount)
        {
            (*m_refCount)--;
            if (*m_refCount == 0)
            {
                delete m_refCount;
                delete m_pointer;
                m_refCount = 0;
                m_pointer = 0;
            }
        }
    }

private:
    int* m_refCount;
    T* m_pointer;
};

调用验证：

#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include "SharedPointer.h"

using namespace std;
class MyClass
{
public:
    ~MyClass()
    {
        cout << "释放MyClass(" << _id << ")\n";
    }

    MyClass(int i) :_id(i)
    {

    }

    void Print() const
    {
        cout << "MyClass(" << _id << ")" << endl;
    }
private:
    int _id;
};

int main()
{
    {
        MyClass* px = new MyClass(1);

        SharedPointer<MyClass> ap(px);
        SharedPointer<MyClass> bp = ap;
        SharedPointer<MyClass> cp;

        cout << "ap的引用计数(2): "
            << ap.GetReferenceCount() << endl;

        cout << "将ap赋值给cp\n";
        cp = ap;

        cout << "ap的引用计数(3): "
            << ap.GetReferenceCount() << endl;


        MyClass* qx = new MyClass(5);
        SharedPointer<MyClass> dp(qx);
        ap = dp;

        cout << "ap的引用计数(2): "
            << ap.GetReferenceCount() << endl;

        cout << "dp的引用计数(2): "
            << dp.GetReferenceCount() << endl;

        //"像指针一样使用智能指针"
        dp->Print();
        (*cp).Print();
    }

    cin.get();
}

手撕strlen

size_t strlen(const char* str) {
    if(str == NULL) {
        return 0;
    }
    const char* pc = str;
    while(*pc++ != '\0');
    return pc - str - 1;
}

手撕strcmp

int strcmp(const char* rhs, const char* lhs) {
    // 判空测试
    assert(rhs != NULL);
    assert(lhs != NULL);
    
    // 注意这里必须是 unsigned char
    // 表示的范围为 0 ~ 255
    // 如果是 char 的话, 范围是 -128 ~ 127, 这个范围用来比较字符串是不对的
    unsigned char c1, c2;
    while(1) {
        c1 = *rhs++;
        c2 = *lhs++;
        if(c1 != c2) {
            return c1 < c2 ? -1 : 1;
        }
        if(c1 == 0) {
            break;
        }
    }
    return 0;
}

手撕智能指针

#pragma once

template<class T>
class SharedPointer
{
public:
    //默认构造函数，内部指针，未指向任何资源，引用计数为0,因为它未与任何资源绑定
    SharedPointer() :m_refCount(nullptr), m_pointer(nullptr) {}

    //构造函数，初始化时，指向一个已经分配好的资源
    SharedPointer(T* adoptTarget) :m_refCount(nullptr), m_pointer(adoptTarget)
    {
        addReference();
    }

    //构造函数，使用其它对象创建新对象
    SharedPointer(const SharedPointer<T>& copy)
        :m_refCount(copy.m_refCount), m_pointer(copy.m_pointer)
    {
        addReference();
    }

    //析构函数，引用计数递减，当为0时，释放资源
    virtual ~SharedPointer()
    {
        removeReference();
    }

    //赋值操作
    //当左值被赋值时，表明它不再指向所指的资源，故引用计数减一
    //之后，它指向了新的资源，所以对应这个资源的引用计数加一
    SharedPointer<T>& operator=(const SharedPointer<T>& that)
    {
        if (this != &that)
        {
            removeReference();
            this->m_pointer = that.m_pointer;
            this->m_refCount = that.m_refCount;
            addReference();
        }
        return *this;
    }

    //判断是否指向同一个资源
    bool operator==(const SharedPointer<T>& other)
    {
        return m_pointer == other.m_pointer;
    }
    bool operator!=(const SharedPointer<T>& other)
    {
        return !operator==(other);
    }

    //指针解引用
    T& operator*() const
    {
        return *m_pointer;
    }
    //调用所知对象的公共成员
    T* operator->() const
    {
        return m_pointer;
    }

    //获取引用计数个数
    int GetReferenceCount() const
    {
        if (m_refCount)
        {
            return *m_refCount;
        }
        else
        {
            return -1;
        }
    }

protected:
    //当为nullpter时，创建引用计数资源，并初始化为1
    //否则，引用计数加1。
    void addReference()
    {
        if (m_refCount)
        {
            (*m_refCount)++;
        }
        else
        {
            m_refCount = new int(0);
            *m_refCount = 1;
        }
    }

    //引用计数减一，当变为0时，释放所有资源
    void removeReference()
    {
        if (m_refCount)
        {
            (*m_refCount)--;
            if (*m_refCount == 0)
            {
                delete m_refCount;
                delete m_pointer;
                m_refCount = 0;
                m_pointer = 0;
            }
        }
    }

private:
    int* m_refCount;
    T* m_pointer;
};
VioletEvergarden丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链式栈的进制转换源代码
11-04
链式栈的进制转换源代码 #define datatype int typedef struct stacknode { int num; datatype data; struct stacknode *pNext; }StackNode; StackNode * init(StackNode * phead);//初始化 StackNode * push(StackNode * phead, int num, datatype data);//进栈 StackNode * pop(StackNode * phead, StackNode * poutdata);//出栈 StackNode * freeall(StackNode * phead);//清空 StackNode * printall(StackNode * phead);//打印</span> #include<stdio.h> #include<stdlib.h>
C++进制转换.pptx
03-30
C++进制转换.pptx
reverse()函数的使用方法
yyj的博客之旅
03-11 9063
reverse()函数的使用方法 1.reverse函数反转string string N; cin>>N; reverse(N.begin(), N.end());//begin，和end； 2.reverse函数反转字符数组 char s[101]; cin.getline(s,sizeof(s)); //也可以不用cin.getline int m=strlen(s); reverse(s,s+m); puts(s); 3.reverse函数反转整型数组 int a[100]
C#学习日记07---数据类型 之 decimal类型
HC666的博客
10-03 1857
值类型之 十进制类型：    C#专门为我们定义了一种十进制类型（decimal）（以前的C/C++是没有次类型的）,主要用于金融或贷币方面的计算。十进制类型是一种高精度、128位数据类型，能保留28或29位有效数字，（double 只有15或16位，上一篇中已经试验过了），虽然它取值的范围要比double小的多，但是要比double精确的多。   当定义一个decimal变量并赋值给
收集的关于DLL较全的介绍
weixin_34319111的博客
03-28 360
天极网 深入浅出Visual C++动态链接库(Dll)编程 VC++动态链接库编程之读者反馈与答复 本文出自：http://blog.sina.com.cn/u/56cacf83010005an 比较大的应用程序都由很多模块组成，这些模块分别完成相对独立的功能，它们彼此协作来完成整个软件系统的工作。可能存在一些模块的功能较为通用，在构造其它软件系统时仍会被使用。在构造软件系统时，...
C++动态链接库DLL文件的加载
爱看书的小沐
12-03 5788
本节内容1、如何从DLL中获得资源（MFC DLL）2、如何使用DEF文件导出函数3、如何显式链接DLL4、如何隐式链接DLL5、如何在DLL中共享数据6、如何在DLL中使用对话框资源(MFC DLL)7、如何在MFC扩展DLL中导出类 1、如何从DLL中获得资源（MFC DLL） LoadLibrary+::LoadString/::LoadIcon/::LoadBitmap HINSTANCE hModule = LoadLibrary(_T("test.dll")); HBITMAP
C++实现万能进制转换
04-08
C++实现进制转换教程 一、资源简介 本资源是一份详尽的C++实现进制转换的教程，旨在帮助读者理解并掌握C++语言在进制转换方面的应用。教程通过清晰易懂的文字说明和实例代码，深入讲解了二进制、八进制、十进制和...
C++任意进制转换
12-04
我的其他资源都是免费的，是对于c语言初学者的帮助比较大的，其中有单片机，ARM，数据结构，window编程，MFC编程，自己编写的小游戏。
C++进制转换.cpp
11-26
c++实现十进制转化为二进制，八进制，十六进制
c/c++进制转换 转中文
06-22
c/c++进制转换 转中文 16进制 2进制 10进制 相互转换........................................................................
VS2010中使用C++创建和使用DL.docx
09-15
VS2010中使用C++创建和使用DL.docx,文档加代码，全了。工程代码下载： 1.生成动态链接库（_declspec(dllexport)方式导出函数） 2.生成动态链接库（以.def文件（模块定义文件）方式导出函数） 3.以加载时动态链接方式调用DLL 4.以运行时动态链接方式调用DLL 5.以模块定义方式（.def文件）建立的动态链接库的调用 遇到的问题： 1.库导入的时候目录的问题。对应文中的问题1，后面有解释。 2.字符集的问题（是Unicode字符集还是多字节集），两种方案，一种修改字符集为多字节集，二是将字符串前面加 _T("")，文中问题2 3.不知道怎么通过模块定义文件方式生成DLL,通过看参考博客的代码找到了答案，主要修改头文件，和添加模块定义文件。 4.模块定义文件中的库文件名应和工程名一致。 DllMain函数 Windows在加载DLL时，需要一个入口函数，就像控制台程序需要main函数一样。有的时候，DLL并没有提供DllMain函数，应用程序也能成功引用DLL，这是因为Windows在找不到DllMain的时候，系统会从其它运行库中引入一个不做任何操作的默认DllMain函数版本，并不意味着DLL可以抛弃DllMain函数。 根据编写规范，Windows必须查找并执行DLL里的DllMain函数作为加载DLL的依据，它使得DLL得以保留在内存里。这个函数并不属于导出函数，而是DLL的内部函数，这就说明不能在客户端直接调用DllMain函数，DllMain函数是自动被调用的。 DllMain函数在DLL被加载和卸载时被调用，在单个线程启动和终止时，DllMain函数也被调用。参数ul_reason_for_call指明了调用DllMain的原因，有以下四种情况： DLL_PROCESS_ATTACH:当一个DLL被首次载入进程地址空间时，系统会调用该DLL的DllMain函数，传递的ul_reason_for_call参数值为DLL_PROCESS_ATTACH。这种情况只有首次映射DLL时才发生； DLL_THREAD_ATTACH:该通知告诉所有的DLL执行线程的初始化。当进程创建一个新的线程时，系统会查看进程地址空间中所有的DLL文件映射，之后用DLL_THREAD_ATTACH来调用DLL中的DllMain函数。要注意的是，系统不会为进程的主线程使用值DLL_THREAD_ATTACH来调用DLL中的DllMain函数； DLL_PROCESS_DETACH:当DLL从进程的地址空间解除映射时，参数ul_reason_for_call参数值为DLL_PROCESS_DETACH。当DLL处理DLL_PROCESS_DETACH时，DLL应该处理与进程相关的清理操作。如果进程的终结是因为系统中有某个线程调用了TerminateProcess来终结的，那么系统就不会用DLL_PROCESS_DETACH来调用DLL中的DllMain函数来执行进程的清理工作。这样就会造成数据丢失； DLL_THREAD_DETACH:该通知告诉所有的DLL执行线程的清理工作。注意的是如果线程的终结是使用TerminateThread来完成的，那么系统将不会使用值DLL_THREAD_DETACH来执行线程的清理工作，这也就是说可能会造成数据丢失，所以不要使用TerminateThread来终结线程。以上所有讲解在工程DLLMainDemo（工程下载）都有体现。 函数导出方式
memcpy的用法
01-06
memcpy 函数用于 把资源内存（src所指向的内存区域） 拷贝到目标内存（dest所指向的内存区域）
【C++】C++封装成DLL并调用（初学者快速入门）
热门推荐
测试开发自动化
03-15 3万+
话不多说，干货走起！！！！！！！****（侵删） 使用vs2019将C++封装成DLL并调用主要有以下几个步骤： 1）新建工程，编写要封装的.cpp和.h文件； 2) 生成动态链接库.dll和静态链接库.lib； 3) 调用通过.h文件调用； 第一步：编写.cpp和.h文件 本例工程名称为RunLIB .cpp如下： #include "pch.h" #include<iostream> class FHello :public IInterface { public: FHello();
用C++实现DL游戏（class方法）
2017gdgzoi999的博客
05-08 988
咳咳，看到别人用C++编了N多游戏，自己怎么不能编一个！本人第一个想到的就是DL（什么）于是，我一气之下，决定开始编。这些是#include、宏什么的#include&lt;cstddef&gt; #include&lt;limits&gt; #include&lt;climits&gt; #include&lt;cfloat&gt; #include&lt;typeinfo&gt; #inclu...
C++DLL封装与调用
Y12010706的博客
06-03 517
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
c++ log函数_DL知识拾贝（Pytorch）(三)：DL元素之二：损失函数
weixin_39793098的博客
11-27 531
知识导图对于一个深度学习的训练过程，可以将它描述为让网络输出值和实际值越来越接近的过程。我们通过训练优化器来完成这个过程，还需要一个评估函数来为我们的优化器指明方向。这个评估函数用来估量模型的预测值和真实值的不一致程度，也就是所谓的损失函数。 Loss函数有很多，并且在很多的深度学习任务中，有时候是需要我们自行去根据任务相关来设计Loss函数的。1. 回归任务中的损失函数1.1 MA...
【C】 初识C语言
努力学习C/C++
04-21 759
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
最新发布
我的博客
04-22 594
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
Linux c++进制转换
08-27
Linux是一种开源的操作系统，C++是一种高级编程语言。在Linux系统中，C++是一种常用的编程语言，可以用于开发各种应用程序，如系统工具、网络应用、游戏等。C++在Linux系统中具有高效、稳定、安全等优势，是开发者的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VioletEvergarden丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值