C语言中的数组切片

在Python中，如果我想将向量

x=（1,2）

分配给

y=（0,0,0,0）

的前两个元素，我会执行类似

y[：1]=x的操作。在C语言中，是否有一个等价物将双x[2]={1,2.}

分配给可用的双y[4]={0,0,0,0.}的前两个元素？或者我必须循环吗？

您可以编写一个函数，传入指针或数组、偏移量和长度。然后，该函数使用malloc（）将空间分配给新指针，并执行memcpy（）操作或循环和复制，尽管memcpy（）可能更好。新指针将返回给调用者。

是的，可以使用函数

memcpy

。但是您必须小心数据类型。您还可以将一种类型的数据复制到另一种类型。正如我所说，你需要小心。否则它可能会生成垃圾值

第二个选项是问题中提到的循环。

试试这个

#include <string.h>
#include <stdio.h>

int main()
{
    double x[2] = {1., 2.};
    double y[4] = {0., 0., 0., 0.};

    memcpy(y, x, 2 * sizeof(*x));
              /* ^ 2 elements of size -> sizeof(double) */

    return 0;
}

#包括
#包括
int main（）
{
双x[2]={1,2.}；
双y[4]={0,0,0,0}；
memcpy（y，x，2*sizeof（*x））；
/*^2个大小元素->大小元素（双）*/
返回0；
}

---

我没有写

sizeof（double）

（没问题），而是写了

sizeof（*x）

，因为如果我更改

x

的类型，我就不需要修复

memcpy

，但在这种情况下，我还必须更改

y

的类型。

试试这个。比python方法低一点，但欢迎使用C，在C中，所有内容迟早都是要分流的原始内存块

宏arraycopy应用一些大小检查。 函数arraycopyunchecked相当原始

这些功能是重叠安全的。在引擎盖下，他们使用

memcopy（，）

，这可能会更慢，但如果意外的锯齿导致重叠的光线，则不会产生意外的结果

#include <stdio.h>
#include <stdlib.h>
#include <string.h> //includes mempcy. I know! I know!

#define arraycopy(dest,doffset,source,soffset,count) arraycopy_((dest),(doffset),(source),(soffset),(count),sizeof(*(dest)),sizeof(*(source)))

int  arraycopy_(void*const dest,const size_t doffset,const void*const source, const size_t soffset,const size_t count,const size_t size,const size_t sizecheck){ 
    if(size!=sizecheck){
        return 1;//Incompatible types.
    }
    memcopy(((char*)dest)+doffset*size,((const char*)source)+soffset*size,count*size);
    return 0;
}

int  arraycopyunchecked(void*const dest,const size_t doffset,const void*const source, const size_t soffset,const size_t count,const size_t size){ 
    memcopy(((char*)dest)+doffset*size,((const char*)source)+soffset*size,count*size);
    return 0;
}


int main(void) {

    int errors=0;

    double dest[]={0.0,0.0,0.0,0.0};
    double source[]={1.0,2.0};

    arraycopy(dest,0,source,0,2);

    if(dest[0]!=1.0){
        ++errors;
    }

    if(dest[1]!=2.0){
        ++errors;
    }   

    if(dest[2]!=0.0){
        ++errors;
    }   

    arraycopy(dest,1,source,0,2);

    if(dest[0]!=1.0){
        ++errors;
    }

    if(dest[1]!=1.0){
        ++errors;
    }   

    if(dest[2]!=2.0){
        ++errors;
    }   


    if(errors!=0){
        printf("Errors - %d\n",errors);
    }else{
        printf("SUCCESS");
    }

    double dest1[]={0.0,0.0,0.0,0.0,0.0};
    double source1[]={1.0,2.0,3.0};

    arraycopy(dest1,2,source1,1,2);

    if(dest[2]!=2.0){
        ++errors;
    }

    if(dest[3]!=3.0){
        ++errors;
    }

   return errors==0?EXIT_SUCCESS:EXIT_FAILURE;
}

#包括
#包括
#include//includes mempcy。我知道！我知道！
#定义arraycopy（dest、doffset、source、soffset、count）arraycopy（dest）、（doffset）、（source）、（soffset）、（count）、sizeof（*（dest））、sizeof（*（source）））
int arraycopy（无效*常量dest，常量大小doffset，常量无效*常量源，常量大小soffset，常量大小计数，常量大小大小，常量大小大小检查）{
如果（尺寸！=sizecheck）{
返回1；//不兼容的类型。
}
memcopy（（（char*）dest）+doffset*size、（（const char*）source）+soffset*size、count*size）；
返回0；
}
int arraycopyunchecked（void*const dest，const size\u t doffset，const void*const source，const size\u t soffset，const size\u t count，const size\u t size）{
memcopy（（（char*）dest）+doffset*size、（（const char*）source）+soffset*size、count*size）；
返回0；
}
内部主（空）{
整数误差=0；
双dest[]={0.0,0.0,0.0,0.0}；
双源[]={1.0,2.0}；
阵列副本（目标，0，源，0,2）；
如果（目标[0]！=1.0）{
++错误；
}
如果（目标[1]！=2.0）{
++错误；
}   
如果（目标[2]！=0.0）{
++错误；
}   
阵列副本（目标，1，源，0,2）；
如果（目标[0]！=1.0）{
++错误；
}
如果（目标[1]！=1.0）{
++错误；
}   
如果（目标[2]！=2.0）{
++错误；
}   
如果（错误！=0）{
printf（“错误-%d\n”，错误）；
}否则{
printf（“成功”）；
}
双dest1[]={0.0,0.0,0.0,0.0,0.0}；
双源1[]={1.0,2.0,3.0}；
阵列副本（dest1,2，source1,1,2）；
如果（目标[2]！=2.0）{
++错误；
}
如果（目标[3]！=3.0）{
++错误；
}
返回错误==0？退出成功：退出失败；
}

有一些库提供这种功能，但C编程语言中没有为其内置任何功能。可能是重复的感谢，我如何控制y的哪两个索引被分配给它？@猜想您可以使用

y+1

从

y[1]的地址开始写入

这个问题被标记为C，我认为它不支持类或运算符重载。