1、cudaMemcpy()<--> cudaMalloc()  //线性内存拷贝

1 //线性内存拷贝
2 cudaMalloc((void**)&dev_A, data_size);
3 cudaMemcpy(dev_A, host_A, data_size, cudaMemcpyHostToDevice);


2、cudaMemcpy2D()<-->cudaMallocPitch() //线性内存拷贝

cudaError_t cudaMemcpy2D(    
    void *     dst,
    size_t     dpitch,
    const void *     src,
    size_t     spitch,
    size_t     width,
    size_t     height,
    enum cudaMemcpyKind     kind     
)    


例：

1 cudaMallocPitch((void**)&devPtr, &pitch, width * sizeof(float), height); 
2 cudaMemcpy2D( void* dst，size_t dpitch，const void* src，size_t spitch，size_t width，size_t height，enum cudaMemcpyKind kind )


3、cudaMemcpy2DToArray()<-->cudaMallocArray() //(二维)线性内存到2维数组的拷贝

 1 cudaError_t cudaMemcpy2DToArray    (    
 2     struct cudaArray *     dst,
 3     size_t     wOffset,
 4     size_t     hOffset,
 5     const void *     src,
 6     size_t     spitch,
 7     size_t     width,
 8     size_t     height,
 9     enum cudaMemcpyKind     kind     
10 )    


例：

 1 void mv(float *y, float *A, float *x, int m, int n)
 2 {
 3     int blkNum = (m >> 4) + ((m & 15) ? 1 : 0); 
 4     int height = blkNum << 4;
 5     int width = (n & 255) ? (((n >> 8) + 1) << 8) : n;
 6     dim3 threads(16, 16);
 7     dim3 grid(blkNum, 1);
 8     cudaArray *d_A;
 9     float *d_x, *d_y;
10 
11     cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float4>();
12     cudaMallocArray(&d_A, &channelDesc, width >> 2, height);
13     cudaMemcpy2DToArray(d_A, 0, 0, A, n * sizeof(float), n * sizeof(float), m, cudaMemcpyHostToDevice);
14     cudaBindTextureToArray(texRefA, d_A);
15     cudaMalloc((void **) &d_x, n * sizeof(float));
16     cudaMalloc((void **) &d_y, m * sizeof(float));
17 
18     cudaMemcpy(d_x, x, n * sizeof(float), cudaMemcpyHostToDevice);
19     mv_kernel<<< grid, threads >>>(d_y, d_A, d_x, m, n);
20     cudaMemcpy(y, d_y, m * sizeof(float), cudaMemcpyDeviceToHost);
21 
22     cudaFree(d_y);
23     cudaFree(d_x);
24     cudaUnbindTexture(texRefA);
25     cudaFreeArray(d_A);
26 }


4、cudaMemcpyToArray()<-->cudaMallocArray()  //(1维)线性内存到2维数组的拷贝

1 cudaError_t cudaMemcpyToArray(    
2     struct cudaArray *     dst,
3     size_t     wOffset,
4     size_t     hOffset,
5     const void *     src,
6     size_t     count,
7     enum cudaMemcpyKind     kind     
8 )    


例：

 1 void initCudaTexture(float *h_volume, float2 *velocity)
 2 {
 3     cudaChannelFormatDesc desc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
 4 
 5     cudaMallocArray(&d_volumeArray, &desc, 128, 128);
 6 
 7     cudaMemcpyToArray(d_volumeArray, 0, 0, h_volume, sizeof(float)*128*128, cudaMemcpyDeviceToDevice);
 8 
 9     tex.normalized = true;
10     tex.filterMode = cudaFilterModeLinear;
11     tex.addressMode[0] = cudaAddressModeWrap;
12     tex.addressMode[1] = cudaAddressModeWrap;
13     
14     cutilSafeCall(cudaBindTextureToArray(tex, d_volumeArray));
15 
16 }


5、cudaMemcpy3D()<-->cudaMalloc3DArray() //(1维)线性内存到3维数组的拷贝 

 1 cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *     p)     
 2 
 3 struct cudaExtent {
 4   size_t width;
 5   size_t height;
 6   size_t depth;
 7 };
 8 struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d);
 9 
10 struct cudaPos {
11   size_t x;
12   size_t y;
13   size_t z;
14 };
15 struct cudaPos make_cudaPos(size_t x, size_t y, size_t z);
16 
17 struct cudaMemcpy3DParms {
18   struct cudaArray     *srcArray;
19   struct cudaPos        srcPos;
20   struct cudaPitchedPtr srcPtr;
21   struct cudaArray     *dstArray;
22   struct cudaPos        dstPos;
23   struct cudaPitchedPtr dstPtr;
24   struct cudaExtent     extent;
25   enum cudaMemcpyKind   kind;
26 };


 例： 

 1 void initCudaTexture(const uchar *h_volume, cudaExtent volumeSize)
 2 {
 3     cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<uchar>();
 4 
 5     cutilSafeCall(cudaMalloc3DArray(&d_volumeArray, &channelDesc, volumeSize));
 6 
 7     cudaMemcpy3DParms copyParams = {0};
 8     copyParams.srcPtr = make_cudaPitchedPtr((void*)h_volume, volumeSize.width*sizeof(uchar), volumeSize.width, volumeSize.height);
 9     copyParams.dstArray = d_volumeArray;
10     copyParams.extent   = volumeSize;
11     copyParams.kind     = cudaMemcpyHostToDevice;
12     cutilSafeCall(cudaMemcpy3D(&copyParams));
13 
14     tex.normalized = true;
15     tex.filterMode = cudaFilterModeLinear;
16     tex.addressMode[0] = cudaAddressModeWrap;
17     tex.addressMode[1] = cudaAddressModeWrap;
18     tex.addressMode[2] = cudaAddressModeWrap;
19 
20     cutilSafeCall(cudaBindTextureToArray(tex, d_volumeArray, channelDesc));
21 }


6、cudaMemcpyToSymbol()  //拷贝到常数存储器

1 __constant__ float constData[256];
2 float data[256];
3 cudaMemcpyToSymbol(constData, data, sizeof(data));
4 cudaMemcpyFromSymbol(data, constData, sizeof(data));
5 __device__ float devData; float value = 3.14f;
6 cudaMemcpyToSymbol(devData, &value, sizeof(float));
7 __device__ float* devPointer; float* ptr;
8 cudaMalloc(&ptr, 256 * sizeof(float));
9 cudaMemcpyToSymbol(devPointer, &ptr, sizeof(ptr));

同样是利用递归思想进行拷贝和释放，大家把递归思想领悟就ok了。
二叉树的内存拷贝算法
//拷贝二叉树 前序递归拷贝
void Copy_PreOrderTraverse(BiTree* dest,BiTree src)
{
	if (NULL != src)
	{
		*dest = malloc(sizeof(BiTNode));
		(*dest)->data = src->data;
		Copy_PreOrderTraverse(&(*dest)->lchild,src->lchild);
		Copy_PreOrderTraverse(&(*dest)->rchild,src->rchild);
	}
	else
	{
		*dest = NULL;
	}
}


二叉树的内存释放算法
//二叉树内存释放 前序递归释放内存
void Free_PreOrderTraverse(BiTree tree)
{
	if (NULL != tree)
	{
		BiTree lchild = tree->lchild;
		BiTree rchild = tree->rchild;
		free(tree);
		Free_PreOrderTraverse(lchild);
		Free_PreOrderTraverse(rchild);
	}
}


完整代码
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef char EleType;
typedef struct BiTNode
{
	EleType data;//数据结点数据域
	struct BiTNode	*lchild, *rchild;//左孩子，右孩子结点指针域
}BiTNode,*BiTree;

//约定通过前序遍历创建结点
//每个结点都有左右孩子，孩子不存在为NULL
void CreatBiTree(BiTree* tree)
{
	char c;
	scanf("%c",&c);
	if (' '== c)
	{
		*tree = NULL;
	}
	else
	{
		*tree = (BiTNode*)malloc(sizeof(BiTNode));
		(*tree)->data = c;
		CreatBiTree(&(*tree)->lchild);//创建左子树
		CreatBiTree(&(*tree)->rchild);//创建右子树
	}
}
void VisitNode(EleType data)
{
	printf("%c ", data);
	return;
}
//前序遍历
void PreOrderTraverse(BiTree tree)
{
	if (NULL != tree)
	{
		VisitNode(tree->data);
		PreOrderTraverse(tree->lchild);
		PreOrderTraverse(tree->rchild);
	}
}

//拷贝二叉树 前序递归拷贝
void Copy_PreOrderTraverse(BiTree* dest,BiTree src)
{
	if (NULL != src)
	{
		*dest = malloc(sizeof(BiTNode));
		(*dest)->data = src->data;
		Copy_PreOrderTraverse(&(*dest)->lchild,src->lchild);
		Copy_PreOrderTraverse(&(*dest)->rchild,src->rchild);
	}
	else
	{
		*dest = NULL;
	}
}
//二叉树内存释放 前序递归释放内存
void Free_PreOrderTraverse(BiTree tree)
{
	if (NULL != tree)
	{
		BiTree lchild = tree->lchild;
		BiTree rchild = tree->rchild;
		free(tree);
		Free_PreOrderTraverse(lchild);
		Free_PreOrderTraverse(rchild);
	}
}

int main(int argc, char *argv[])
{
	BiTree tree = NULL,newTree = NULL;
	printf("请按前序遍历的方式输入结点数据，孩子结点为NULL用空格代替：");
	CreatBiTree(&tree);
	Copy_PreOrderTraverse(&newTree, tree);
	printf("源二叉树的前序遍历：");
	PreOrderTraverse(tree);
	printf("\n新二叉树的前序遍历：");
	PreOrderTraverse(newTree);
	printf("\n");
	//释放二叉树内存
	Free_PreOrderTraverse(newTree);
	return 0;
}


代码运行测试
我们下图的二叉树进行测试。



运行结果如下，注意：我们创建结点时的前序输入:ABC__D__EF__G__，一个_表示一个空格哟。

字符串拷贝和内存拷贝函数： 

 

strcpy（拷贝字符串）   

定义函数：char *strcpy( char *dest, const char *src ); 

strcpy()函数只能拷贝字符串。strcpy()函数将源字符串 src 的每个字节拷贝到目的字符串 dest 中，src 字符串末尾的'\0'也被拷贝过去。strcpy()函数返回参数 dest 的起始地址。如果参数 dest 所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况（程序员必须保证目标字符数组的空间足够容纳需要复制的字符串。如果src 字符

串比dest字符串长，多余的字符仍将被复制，它们将覆盖原先存储于dest数组后面的内存空间的值），在编写程序时请特别留意，或者用strncpy()来取代。如果参数 src 和 dst 在内存中出现重叠，其结果是未定义的。


 

strncpy（拷贝字符串）   

定义函数：char *strncpy( char *dest, const char *src, size_t n ); 

strncpy()会将参数 src 字符串拷贝前 n 个字符至参数 dest 所指的地址。 函数返回参数 dest 的字符串起始地址。 
注意 n 的取值范围，不要超过 src 和 dest 的长度。 

#include<string.h> 

#include<stdio.h> 

 

int main() 

{ 

    char a1[30]="string(1)"; 

    char b1[]="STRING(2)"; 

    printf("before strcpy()  : %s\n", a1 ); 

    printf("after  strcpy()   : %s\n", strcpy( a1, b1 ) ); 

 

    char a2[30]="string(1)"; 

    char b2[]="STRING(2)"; 

        printf("before strncpy() : %s\n", a2 ); 

        printf("after    strncpy() : %s\n", strncpy( a2, b2, 6 ) ); 

}   

  

memcpy（拷贝内存内容）    
定义函数：void * memcpy( void * dest, const void *src, size_t n ); memcpy()用来拷贝 src 所指的内存内容前 n 个字节到 dest所指的内存地址上。与 strcpy()不同的是，memcpy()会完整的复制 n 个字节，不会因为遇到字符串结束'\0'而结束。memcpy()函数可以拷贝任意类型的数据。memcpy()函数返回指向 dest 的指针。指针 src 和 dest 所指的内存区域不可重叠。在拷贝字符串时，通常都使用 strcpy()函数；在拷贝其它数据(例如结构)时，通常都使用
 memcpy()函数。 

 

memmove（拷贝内存内容）   

定义函数：void *memmove(void *dest, const void *src, size_t n ); 

memmove()与 memc py()一样都是用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址上。不同的是，当src 和 dest 所指的内存区域重叠时，memmove()仍然可以正确的处理，不过执行效率上会比使用 memcpy()略慢些。该函数返回指向 dest 的指针。


#include<string.h> 

 

int main() 

{ 

    char a[30]="string(1)"; 

    char b[]="string(2)"; 

        printf("before strcpy() :%s\n", a ); 

        printf("after strcpy() :%s\n", strcpy( a, b ) ); 

 

    a[30]="string(1)"; 

    b[]="string(2)"; 

        printf("before strncpy() : %s\n", a ); 

        printf("after strncpy() : %s\n", strncpy( a, b, 6 ) ); 

}  

memccpy（拷贝内存内容）   

定义函数：void * memccpy( void *dest, const void *src, int c, size_t n ); 

memccpy()用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址上。与 memcpy()不同的是，memccpy()会在复制时检查参数 c 是否出现，若是则返回 dest 中值为 c 的下一个字节地址。该函数返回指向 dest 中值为 c的下一个字节指针。返回值为 NULL 表示在 src 所指内存前 n 个字节中没有值为 c 的字节。 


 

#include<string.h> 

#include<stdio.h> 

 

int main() 

{ 

    char a[]="string(a)"; 

    char b[]="string(b)"; 

    char *p; 

     

        p = ( char * )memccpy( a, b, 'k', sizeof( b ) ); 

     

        if( p == NULL ) 

    { 

        // 注意p 为NULL 的情况，这时不能读取p 所指的地方的内容  

                printf("the return pointer of mymccpy is null !\n"); 

    } 

    else 

    { 

                printf("memccpy(): %s, *p = %c\n", a, *p ); 

    } 

}  

 

bcopy （拷贝内存内容）   

定义函数：void bcopy ( const void *src,void *dest ,int n);  

bcopy()与 memcpy()一样都是用来拷贝 src 所指的内存内容前 n 个字节到 dest 所指的地址，不过参数 src 与 dest在传给函数时是相反的位置。建议使用 memcpy()取代 。

void *memcpy(void *dest, const void *src, size_t n);

解释： 

memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

下面是游戏开发中的一个具体的应用： 


FR：徐海涛（hunk Xu) QQ技术交流群：386476712