数组和数组之间能直接赋值吗？——不能
 
你难道是想 a=b??
 首先你要明白:
 数组名a,b代表指针常量,所以说赋值号左边必须是一个变量
 a=b;
 根本就是错误的
 
 
 
注意：数组名是常量，指针一般都是变量，当然也可以是常量。查看：https://blog.csdn.net/cyj2014go/article/details/78203404
 
 
法一：
 
当然你的想法也有可取之处，取地址运算，把数组a的首地址赋给B数组，不过这要通过指针来实现
 例 
 
#include <iostream>
 #include <cstring>
 using namespace std;
 
int main()
 {
     int a[5]={1,2,3,4,5};
     int *p = new int [5];   //指针变量
     p = a;
     for(int i=0;i<5;i++)
     {
         cout<<*(p+i)<<" ";
     }
     cout<<endl;  
 }//使用任何数据
 
法二
 
#include <iostream>
 #include <cstring>
 using namespace std;
 
int main()
 {
     int a[5]={1,2,3,4,5};
     int b[5];
     int i;
     for(i=0;i<5;i++)
     {
         b[i]=a[i];
     }
     for(i=0;i<5;i++)
     {
         cout<<b[i]<<" ";
     }
     cout<<endl;
     return 0;
 }
 //任何数据
 
法三
 
#include <iostream>
 #include <cstring>
 using namespace std;
 
int main()
 {
     char a[6]={"abcde"};
     char b[6];
     strcpy(b,a);
     cout<<b<<endl;
     return 0;
 }
 //缺点，只能是字符数组
 

法四
 
#include <iostream>
 #include <cstring>
 using namespace std;
 int main()
 {
 
    int a[6]= {1,2,3,4,5,6};
     cout<<sizeof(a)<<endl;;
     int b[6];
     memcpy(b,a,sizeof(a));
     for(int i=0;i<6;i++)
     {
         cout<<b[i]<<" ";
     }
     cout<<endl;
     return 0;
 }
//任何数据
 
 
 
 
 
 

两数组间能通过数组名直接赋值吗？——不能
 
eg：
    char charr1[20];
    char charr2[20] = " afddffgfsf "  
 
那么 `charr1 = charr2` 是否成立呢？不妨尝试一下：
 

 图中错误提示：无效的数组分配，为什么会这样呢？
 首先，数组名是一个地址常量，其值和第一个元素的地址值相同，不可修改。
 那么，你会想什么是地址常量，有什么作用？ 如果觉得麻烦，可以直接看整理思路
 （引用原文链接：https://blog.csdn.net/cyj2014go/article/details/78203404）
 1.指针变量：指针值（即指针的指向）可以改变的指针，只能指向变量；
 2.指针常量：指针值（即指针的指向）不能改变的指针，只能指向变量，但可以修改指向的实体变量的值；
 3.常量指针：指向常量的指针，所以不能修改指向的实体的值，但可以修改指针的指向（即可以指向别的常量，必须是常量）；
 4.常量指针常量：指向常量，指针不能改变指向的实体的值，指针值（即指针的指向）也不能改变（是2和3的结合）。
 
const int a = 78; //整型常量
 int b = 10; //b和c是整型变量
 int c = 18;
 int* kp = &b; //指针变量
 const int* ip = &a; //常量指针
 int const* dp = &b; //常量指针
 int* const cp = &a; //错，定义了指针常量，但不能指向实体常量
 int* const cp = &b; //指针常量
 const int* const icp = &c; //常量指针常量
 //const在前是常量指针；const在后是指针常量（注意：没有这种定义形式 const* int d;）
 
*kp = 90; //对，能修改指向的实体的值
 kp = &a; //错，只能指向实体变量
 
*ip = 87; //错，常量指针不能修改指向的实体的值
 ip = &c; //对，常量指针能指向的实体能修改（即指针值）
 
*cp = 81; //错，指针常量能修改指向的实体的值
 cp = &b; //错，指针常量指向的实体不能改变（即指针值）
 
*icp = 33; //错，常量指针常量不能修改指向的实体的值
 icp = &b; //错，常量指针常量不能修改指向（即指针值）
 int d = *icp; //对，可以读间访值
 
————————————————
 ————————————————
 ————————————————
 ————————————————
 ————————————————
 
整理一下思路：数组的指针也就是数组名是地址常量，这个常量代表地址而已。
 
 弄明白了数组名的本质，那我们就清楚为什么数组名之间不能互相赋值了。因为 常量 ≠ 常量 ，例：123 ≠ 456。
 那我们应该怎么解决这个问题呢？参考https://blog.csdn.net/cyj2014go/article/details/78203404
 法一：
 通过指针的方式。
 
int main()
{
 int a[5]={1,2,3,4,5};
 int *p = new int [5];   //**新开辟空间，且增加新的指针指向该空间的首地址， p 为指针变量**
 p = a;                  //将地址常量赋值给指针变量
 for(int i=0;i<5;i++)
 {
	cout<<*(p+i)<<" ";
 }
 cout<<endl;
}
 
法二
 
int main()
{
    int a[5]={1,2,3,4,5};
    int b[5];
    int i;
    for(i=0;i<5;i++)
    {
        b[i]=a[i];
    }
    for(i=0;i<5;i++)
    {
        cout<<b[i]<<" ";
    }
    cout<<endl;
    return 0;
}
 
//任何数据
 
法三：
 
int main()
{
    char a[6]={"abcde"};
    char b[6];
    strcpy(b,a);
    cout<<b<<endl;
    return 0;
}
 
//缺点，只能是字符数组
 
法四：
 
int main()
{
    int a[6]= {1,2,3,4,5,6};
    cout<<sizeof(a)<<endl;;
    int b[6];
    memcpy(b,a,sizeof(a));
    for(int i=0;i<6;i++)
    {
        cout<<b[i]<<" ";
    }
    cout<<endl;
    return 0;
}
 
任何数据
 
————————————————
 注意：
 指针变量和数组在访问数组中元素时，一定条件下其使用方法具有相同的形式，因为指针变量和数组名都是地址量。
 但指针变量和数组的指针（或叫数组名）在本质上不同，指针变量是地址变量，而数组的指针是地址常量。

在Java里面,可以用复制语句”A=B”给基本类型的数据传递值,但是如果A,B是两个同类型的数组,复制就相当于将一个数组变量的引用传递给另一个数组;如果一个数组发生改变,那么引用同一数组的变量也要发生改变.
以下是归纳的JAVA中复制数组的方法：
1.使用FOR循环,将数组的每个元素复制或者复制指定元素,不过效率差一点
2.使用clone方法,得到数组的值,而不是引用,不能复制指定元素,灵活性差一点
3.使用System.arraycopy(src, srcPos, dest, destPos, length)方法,推荐使用
举例：
1.使用FOR循环
int[] src={1,3,5,6,7,8};
int[] dest = new int[6];
for(int i=0;i<6;i++) dest[i] = src[i];
2.使用clone
int[] src={1,3,5,6,7,8};
int[] dest;
dest=(int[]) src.clone();//使用clone创建
副本,注意clone要使用强制转换
3.使用System.arraycopy
int[] src={1,3,5,6,7,8};
int[] dest = new int[6];
System.arraycopy(src, 0, dest, 0, 6);
——————————————————————-
System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制.
其函数原型是：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src:源数组; srcPos:源数组要复制的起始位置;
dest:目的数组; destPos:目的数组放置的起始位置;
length:复制的长度.
注意：src and dest都必须是同类型或者可以进行转换类型的数组．
有趣的是这个函数可以实现自己到自己复制,
比如：int[] fun ={0,1,2,3,4,5,6};
System.arraycopy(fun,0,fun,3,3);
则结果为：{0,1,2,0,1,2,6};


转载自 http://blog.csdn.net/sinat_29384657/article/details/51768779

在C或者C++中，很多书在讲数组的时候都会强调一点，数组不能直接整体赋值；
 比如 int a[3] ={1,2,3};
 int b[3];
 a = b;
 这样是错误的，但是很少有课本会说这为什么是错的；（至少我感觉是这样的）
 以下是个人理解;
 int a[3] , b[3];
 大家知道在定义数组的时候 a 和 b 都是地址常量；
 而在C语言中 常量是无法赋值的，所有 a = b ;
 这个是不合法操作 ；