反映HBV活动性复制的指标有哪些 怎样把一个指标的内容复制给另一个指标(两个指标都有值），资料库中线性表怎么做

怎样把一个指标的内容复制给另一个指标(两个指标都有值），资料库中线性表怎么做  

怎样把一个指标的内容复制给另一个指标(两个指标都有值），资料库中线性表怎么做

1、如果这两个指标中接收值的那个是变数，可以直接赋值。比如：int *p,a; p=&a;
2、如果接收值的指标是常量（地址常量），则只能使用其他方式。比如：char s[80],s1[60]="chinese"; 则只能：strcpy(s,s1);
3、如果想在C语言中实现资料库中的线性表，可以有两种方式：（1）使用阵列（顺序储存结构）（2）使用单链表（链式储存结构）。
如果想将线性表储存起来，并进行查询等操作。可以使用fread()、fwirte()函式将线性表的内容储存到档案中，再根据需要从档案中读出来操作。

C语言，怎么把一个指标的内容复制到另一个指标？

直接对指标进行赋值即可实现把一个指标的内容复制到另一个指标。

下面举例来说明具体的操作过程：

int *p1=(int *)malloc(sizeof(int)); 定义一个int型别的指标变数p1，并分配储存单元int *p2; 定义一个int型别的指标变数p1，没有分配储存单元*p1 = 4; 对指标p1指向的储存单元赋值p2 = p1; 将指标p2也指向指标p1指向的储存单元，即*p2=4printf("%d", *p2); 输出4

如何复制指标内的资料到另一个指标

可以将指标的内容储存在一个快取的变数里面，或者储存在本地档案中，然后取出赋值给另一个指标。

我想问一下怎么把一个指标指向的记忆体中数值复制给另一个指标

就是想动态申请记忆体嘛，用一个malloc就可以了
#include "stdio.h"
#include "stdlib.h"
int main()
{
char* p = "abcdefg";
char* q = (char*)malloc(10);
printf("%sn",p);
q=p;指标赋值，即指向的地址相同
printf("%sn",q);

return 0;
}

如果两个指标都指向同一记忆体，用free释放其中的一个指标后，另一个指标还能引用这个记忆体里的资料吗？？？

free的实质是将这段记忆体标记为可再分配，但是里面的资料没有被清空，所以如果你用另一个指标再次呼叫还能够识别出刚刚的资料，但存在很大的危险性，建议释放时2个指标都指向NULL

定义一个指标阵列,用另一个指标p储存指标阵列的第一个指标的地址,怎样定义以p为引数，对指标阵列进

阵列指标（也称行指标）
定义 int (*p)[n];
()优先顺序高，首先说明p是一个指标，指向一个整型的一维阵列，这个一维阵列的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型资料的长度。
如要将二维阵列赋给一指标，应这样赋值：
int a[3][4];
int (*p)[4]; 该语句是定义一个数组指标，指向含4个元素的一维阵列。
p=a; 将该二维阵列的首地址赋给p，也就是a[0]或&a[0][0]
p++; 该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]
所以阵列指标也称指向一维阵列的指标，亦称行指标。
指标阵列
定义 int *p[n];
[]优先顺序高，先与p结合成为一个数组，再由int*说明这是一个整型指标阵列，它有n个指标型别的阵列元素。这里执行p+1时，则p指向下一个阵列元素，这样赋值是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指标变数可以用来存放变数地址。但可以这样 *p=a; 这里*p表示指标阵列第一个元素的值，a的首地址的值。
如要将二维阵列赋给一指标阵列:
int *p[3];
int a[3][4];
p++; 该语句表示p阵列指向下一个阵列元素。注：此阵列每一个元素都是一个指标
for(i=0;i<3;i++)
p[i]=a[i]
这里int *p[3] 表示一个一维阵列记忆体放著三个指标变数，分别是p[0]、p[1]、p[2]
所以要分别赋值。

怎样把一个数组指标指向的内容放到另一个数组中？

for(i=0;i<3;i++)
{ b[i]=*p;
p++;
}

C语言：传入两个字串型指标，把其中一个指标所指向的地址空间中的内容复制到另一个指标所指向的地址空间

程式清单 1 V0.1版程式
void MyMemMove(char *dst,char *src,int count)
{
while(count--)
{
*dst++ = *src++;
}
}
程式清单 2 测试用例
void Test()
{
char p1[256] = ”hello,world!”;
char p2[256] = {0};
MyMemMove(p2,p1,strlen(p1)); printf(“%s”,p2);
}
程式清单 3 V0.2版程式
void MyMemMove(void *dst,void *src,int count)
{
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
有的同学可能会问，这里面不是还有指标强制转换吗？只不过是换了地方。没错，强制指标转换确实是从使用者的程式码转移到了库的程式码里，但我们可以将 MyMemMove理解为库，而将Test理解为使用者，事实上通过调整之后的效果却有天壤之别，V0.1是一逸永劳，而V0.2是一劳永逸！
还有几个细节需要注意，为了实现链式表示式，我们应该将返回值也改为void *。此外，如果我们不小心将“*(char *)dst = *(char *)src;”写反了，写成“*(char *)src = *(char *)dst;”编译照样通过，而为了找出这个错误又得花费不少时间。注意到src所指向的内容在这个函式内不应该被改变，所有对src所指的内容赋值都应该被禁止，所以这个引数应该用const修饰，如果有类似的错误在编译时就能够被发现：
error C3892: 'src' : you cannot assign to a variable that is const
作为程式设计师犯错误在所难免，但是我们可以利用相对难犯错误的机器，也就是编译器来降低犯错误的概率，这样我们就得到了V0.3版的程式。
程式清单 4 V0.3版程式
void * MyMemMove(void *dst,const void *src,int count)
{
void *ret=dst;
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return ret;
}
现在再来考虑这样一种情况，有使用者这样呼叫库：MyMemMove(NULL,src, count)，这是完全可能的，因为一般来说这些地址都是程式计算出来的，那就难免会算错，出现零地址或者其它的非法地址也不足为奇。可以预料的是，如果出现这种情况的话，则程式马上就会down掉，更糟糕的是你不知道错误出在哪里，于是不得不投入大量的精力在浩瀚的程式码中寻找bug。解决这类问题的通用办法是对输入引数作合法性检查，也就是V0.4版程式。
程式清单 5 V0.4版程式
void * MyMemMove(void *dst,const void *src,int count)
{
void *ret=dst;
if (NULL==dst||NULL ==src)
{
return dst;
}
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return ret;
}
上面之所以写成“if (NULL==dst||NULL ==src)”而不是写成“if (dst == NULL || src == NULL)”，也是为了降低犯错误的概率。我们知道，在C语言里面“==”和“=”都是合法的运算子，如果我们不小心写成了“if (dst = NULL || src = NULL)”还是可以编译通过，而意思却完全不一样了，但是如果写成“if (NULL=dst||NULL =src)”，则编译的时候就通不过了，所以我们要养成良好的程式设计习惯：常量与变数作条件判断时应该把常量写在前面。
V0.4版的程式码首先对引数进行合法性检查，如果不合法就直接返回，这样虽然程式dwon掉的可能性降低了，但是效能却大打折扣了，因为每次呼叫都会进行一次判断，特别是频繁的呼叫和效能要求比较高的场合，它在效能上的损失就不可小觑。
如果通过长期的严格测试，能够保证使用者不会使用零地址作为引数呼叫MyMemMove函式，则希望有简单的方法关掉引数合法性检查。我们知道巨集就有这种开关的作用，所以V0.5版程式也就出来了。

程式清单 6 V0.5版程式
void * MyMemMove(void *dst,const void *src,int count)
{
void *ret=dst;
#ifdef DEBUG
if (NULL==dst||NULL ==src)
{
return dst;
}
#endif
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return ret;
}
如果在除错时我们加入“#define DEBUG”语句，增强程式的健壮性，那么在除错通过后我们再改为“#undef DEBUG”语句，提高程式的效能。事实上在标准库里已经存在类似功能的巨集：assert，而且更加好用，它还可以在定义DEBUG时指出程式码在那一行检查失败，而在没有定义DEBUG时完全可以把它当作不存在。assert(_Expression)的使用非常简单，当_Expression为0时，侦错程式就可以出现一个除错错误，有了这个好东西程式码就容易多了。
程式清单 7 V0.6版程式
void * MyMemMove(void *dst,const void *src,int count)
{
assert(dst);
assert(src);
void *ret=dst;
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return ret;
}
一旦呼叫者的两个指标引数其中一个为零，就会出现如图1所示的错误，而且指示了哪一行非常容易查错。
到目前为止，在语言层面上，我们的程式基本上没有什么问题了，那么是否真的就没有问题了呢？这就要求程式设计师从逻辑上考虑了，这也是优秀程式设计师必须具备的素质，那就是思维的严谨性，否则程式就会有非常隐藏的bug，就这个例子来说，如果使用者用下面的程式码来呼叫你的程式。
程式清单 8 重叠的记忆体测试
void Test()
{
char p [256]= "hello,world!";
MyMemMove(p+1,p,strlen(p)+1);
printf("%sn",p);
}
如果你身边有电脑，你可以试一下，你会发现输出并不是我们期待的“hhello,world!”（在“hello world！”前加个h），而是“hhhhhhhhhhhhhh”，这是什么原因呢？原因出在源地址区间和目的地址区间有重叠的地方，V0.6版的程式无意之中将源地址区间的内容修改了！有些反映快的同学马上会说我从高地址开始拷贝。粗略地看，似乎能解决这个问题，虽然区间是重叠了，但是在修改以前已经拷贝了，所以不影响结果。但是仔细一想，这其实是犯了和上面一样的思维不严谨的错误，因为使用者这样呼叫还是会出错：
MyMemMove( p, p+1, strlen(p)+1);
所以最完美的解决方案还是判断源地址和目的地址的大小，才决定到底是从高地址开始拷贝还是低地址开始拷贝，所以V0.7顺利成章地出来了。
程式清单 9 V0.7版程式
void * MyMemMove(void *dst,const void *src,int count)
{
assert(dst);
assert(src);
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count)) {
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else {
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}
经过以上7个版本的修改，我们的程式终于可以算是“工业级”了。

sqlserver 2000 把一个数据库中的表复制到另一个数据库中，

在企业管理器中,在要复制表的资料库上点右键 所有任务->汇入资料->下一步->选择资料来源->选择目的资料库->选择要复制的表->.....就OK了

C语言中，有一个指向指标阵列的指标，我想要问要怎么交换两个指标的值来做到，将指标数组里的指标排序。

int *arry[10]; 指标阵列 int (*arryp)[10]; 阵列指标，因为阵列指标指向阵列，而阵列也可看做是个指标，那阵列指标可以理解为一个二 级指标 int a[10]; arryp = &a; 将阵列地址个数组指标 arry[0] = *arryp; arry[0]是一级指标，要将阵列指标赋给指标阵列，就要取内容，实际就是 arry[0] = a;