C语言中的数组为什么不可赋值给另一个数组？

因为数组为指针常量，如 int a[]; int b[]; b = a; 是错误地，因为 int a[] 是 int * const a, int b[] 是 int * const b，一个指针常量不可以被另一个指针常量修改（地址常量不可以被修改）。

数组的初始化，除了遍历赋值，还可以怎么被赋值？

数组在全局变量时，int可以被编译器赋值为0；作为局部变量时，需要进行赋值进行初始化，否则会出现奇怪的数字。

局部变量 int a[10] = {0};  int a[10] = {1}; int a[10] = {[2]=3,4,[5]=8} 是缺省的赋值，其他值为0。

c: 将一个数组拷贝到另一个数组
以下是代码：
#include<iostream>  //引用c++标准库，#include<stdio.h>是引用c的标准库
using namespace std;
void main()
{
	char a[]="abcd";  //声明数组a[]，且将字符串"abcd"赋值给它；
	char b[4];    //声明数字b[4];系统会在字符串后自动添加 空值符 '\0'
	for (int i=0;a[i]!='\0';i++)   //当a数组拷贝给b数组
		b[i]=a[i];
	b[i]='\0';        //需在b数组后加上空值符号,否则b[]=abcdabcd
	printf("b[4]=%s\n",b);
}

代码执行结果：

C语言数组、字符串

一维数组 
数组必须先定义，然后使用
C语言规定只能逐个引用数组元素而不能一次引用整个数组
不能直接将一个数组赋给另一个数组
不能为数组整体赋值
字符数组与字符串 
字符串常量是由一对双引号括起来的字符序列
字符串中每个字符作为一个数组元素存储（占一个字节）
对于wchar_t类型的字符常量，需要在字符前面加上L，在实际使用中，wchar_t类型的字符前面可以不用加L
对于wchar_t类型的字符串常量，需要在字符串前面加上L。
字符数组的输入和输出 
获取字符串长度
strlen（str）
strnlen_s（str，100）
wchar_t（str）
wcsnlen_t（str，100）
字符串拷贝 
strcpy（str）
strcpy_s（str，100）
wcscpy（str）
wcscpy_s（str，100）
字符串比较 
strcmp（str，str2）
wcscmp（str，str2）
字符串连接 
strcat（str，str2）
strcat_s（str，100，str2）
wcscat（str，str2）
wcscat_s（str，100，str2）
_getch()函数包含在conio.h的头文件中。
避免数据溢出 
浮点数总采用double类型
整数总采用int类型
代码整理

3-1



#include <stdio.h>
int main()
{
    int i, j, k;
    printf("\n");
    for (i = 1; i < 5; i++)
        for (j = 1; j < 5; j++)
            for (k = 1; k < 5; k++)
                if (i != k&&i != j&&j != k)
                    printf("%d,%d,%d\n", i, j, k);

}

3-2



#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a;
    scanf_s("%d", &a);
    //if (a>0)
    //{
    //printf("yes");
    //}
    //else
    //{
    //printf("no");
    //}

    /*if (a%2==0)
    {
        printf("yes");
    } 
    else
    {
        printf("no");
    }*/
    /*if (a % 4 == 0)
    {
        if (a%400==0)
        {
            printf("run");
        } 
        else
        {
            if (a % 100 != 0)
            {
                printf("run");
            }
            else
            {
                printf("ping");
            }
        }

    }
    else
    {
        printf("ping");
    }*/
    /*if (a==1)
    {
        printf("星期一\n");
    } 
    else if (a==2)
    {
        printf("星期二\n");
    } 
    else if (a==3)
    {
        printf("星期三\n");
    } 
    else if (a == 4)
    {
        printf("星期四\n");
    }
    else if (a == 5)
    {
        printf("星期五\n");
    }
    else if (a == 6)
    {
        printf("星期六\n");
    }
    else if (a == 7)
    {
        printf("星期日\n");
    }
*/
    switch (a)
    {
    case 1:
        printf("星期一\n");
        break;
    case 2:
        printf("星期二\n");
        break;
    case 3:
        printf("星期三\n");
        break;
    case 4:
        printf("星期四\n");
        break;
    case 5:
        printf("星期五\n");
        break;
    case 6:
        printf("星期六\n");
        break;
    case 7:
        printf("星期日\n");
    default:
        printf("error\n");
        break;
    }
    system("pause");
    return 0;
}

3-3



// day3-03.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <string>
#include <stdio.h>
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{
    int a1,a2,b1, b2;
    char strChrA[100] = "abcdef";
    a1=strlen(strChrA);
    a2=strnlen_s(strChrA, 100);
    printf("%d%d\n", a1, a2);
    wchar_t strChrAB[100] = L"abcdef";
    b1=wcslen(strChrAB);
    b2=wcsnlen_s(strChrAB,100);
    printf("%d%d\n", b1, b2);
    system("pause");
    return 0;
}

3-4



// day3-04.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{

    int c = 'A';
    putchar(c);
    putchar('\n'); 
    putchar('A');
    putchar('\n');
    putchar(65);
    putchar('\n');
    putchar('5');
    putchar('\n');
    putchar('5' + 1);
    system("pause");
    return 0;
}

3-5



// day3-05.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <conio.h>//注意_getch()的头文件是这个
int _tmain(int argc, _TCHAR* argv[])
{
    char ch =_getch();
    return 0;
}

3-6



// day3-06.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <string>
int _tmain(int argc, _TCHAR* argv[])
{
    char strChA[100];
    char strChB[] = "xxxxx";
    strcpy_s(strChA, 100, strChB);
    printf("%s\n", strChA);
    wchar_t strChc[100];
    wchar_t strChd[] = L"yyyyy";
    wcscpy_s(strChc,20, strChd);
    wprintf(L"%s\n", strChc);
    system("pause");
    return 0;
}

3-7



// day3-07.cpp : 定义控制台应用程序的入口点。
//字符串比较
#include "stdafx.h"
#include <string>
int _tmain(int argc, _TCHAR* argv[])
{   
    char stra[] = "aaaaa";
    char strb[] = "bbbbb";
    int nRet = strcmp(stra, strb);
    printf("%d\n", nRet);
    wchar_t strc[] = L"yyyy";
    wchar_t strd[] = L"yyyy";
    nRet = wcscpy_s(strc, 5, strd);
    printf("%d\n", nRet);
    system("pause");
    return 0;
}

3-8



// day3-08.cpp : 定义控制台应用程序的入口点。
//字符串连接
#include "stdafx.h"
#include <stdlib.h>
#include <string.h>
int _tmain(int argc, _TCHAR* argv[])
{
    char str1[30] = { "People's Republic of " };
    char str2[] = { "China" };
    strcat_s(str1, 30,str2);
    printf("%s\n", str1);
    system("pause");
    return 0; 
}

3-9



// day3-09.cpp : 定义控制台应用程序的入口点。
//再谈输入输出
#include "stdafx.h"
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{
    char ch;
    scanf_s("%c", &ch, 1);
    char string[100];
    scanf_s("%s", &string, 100);
    wchar_t string2[100];
    wscanf_s(L"%s", &string2, 100);
    system("pause");
    return 0;
}

3-10



// day3-11.cpp : 定义控制台应用程序的入口点。
//使用if与goto构造循环结构
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
    int i = 1, sum = 0;
loop:
    if (i <= 100)
    {
        sum = sum + i;
        i++;
        goto loop;
    }
    printf("%d\n", sum);
    return 0;
}

3-11



//day3-10.cpp : 定义控制台应用程序的入口点。
//switch-case 实现会移动的坐标
#include "stdafx.h"
#include <conio.h>
int _tmain(int argc, _TCHAR* argv[])
{
    int zbX = 10, zbY = 10;
sign:
    char ch = _getch();
    switch (ch)
    {
    case 'W':
    case 'w':
    {
        zbY--;
        printf("向上：X=%d,Y=%d", zbX, zbY);
        break;
    }
    case 's':
    case 'S':
    {
        zbY++;
        printf("向下：X=%d,Y=%d", zbX, zbY);
        break;
    }
    case 'a':
    case 'A':
    {
        zbX--;
        printf("向左：X=%d,Y=%d", zbX, zbY);
        break;
    }
    case 'd':
    case 'D':
    {
        zbX++;
        printf("向右：X=%d,Y=%d", zbX, zbY);
        break;
    }
    default:
        break;
    }
    goto sign;
    return 0;
    return 0;
}

我曾说过，在c语言中只有一维的数组（这是我对数组的看法），而且数组元素可以是任何类型的数据（或对象），自然也可以是另外的一个数组（因为数组也是一种数据类型）。所以如果你坚持要说有多维数组，那也不是不可能的事情。我们只要把一个数组赋值给另一个数组的元素就可以了。当然了，我们必须保证在程序编译期数组的大小是一个固定的常数。
　　其实，数组的操作很简单的。只要我们确定一个数组的大小和指向该数组下标为0的元素的指针，其他的任何一个数组下标的运算都等同于一个对应的指针运算，所以我们说“数组和指针是可以相互操作的”。两者的本质是一样的。甚至我们还可以把数组看作是一个“指针”的集合。
　　我可以通过如下的方式声明一个数组：
　　charname;
　　这个语句声明了name是一个拥有10个字符型元素的数组。类似的
　　structstudent｛
　　inttid;
　　charname;
　　charsex;
　　charaddress【25】;
　　｝std【100】;
　　这里声明了std是一个拥有100个元素的数组，而且std中的每一个元素都定义了一名学生的基本信息，每一个元素都是一个结构，其中包括一个拥有4个整形元素的数组（tid），用来记录学生的学好；还有一个拥有10个字符型元素的数组（name），用来记录学生的名字；一个用来记录学生性别的字符（sex）;还有一个记录学生住址，拥有25个字符型元素的数组（address【25】）。数组是一个很灵活的结构。
　　所谓的“二维数组”或“矩阵”是很容易声明的，例如：
　　intweek【24】;
　　这里把声明week声明为一个拥有7个数组元素的数组（这样解释，不会感觉奇观吧），其中每一个元素都是拥有24个整数型元素的数组。注意了不能把week理解为一个拥有24个数组元素的数组，其中每一个元素是一个拥有7个整形元素的数组。还有，如果week不是用于sizeof的操作数，那么它总是被一个指向week数组起始地址的指针。这里又和指针磨合了。如果一个指向的是一个数组的一个元素，那么我们只需给这个指针加上一个自然数i（0＝%26lt;i%26lt;数组的上边界的值），那么就可以得到一个指向该数组的弟i个元素的指针。如果在此基础上减去1，那么就得到了一个指向前一个元素的指针。这样的操作很简单很灵活的。但是这儿也有一个误区：好多人都认为“给一个指针加一个整数，就等同于给该指针的二进制数表示加上一个同样的整数”。其实，这是一个很容易犯的错误了，至少在初学c语言的时候，我就犯过这个错误，而且不仅一次。其实，这两者的含义是截然不同的。假设我们有一个这样的指针声明语句：
　　intp;
　　那么p自然是一个指向整数指针了，那么p+1指向的是计算机内存的下一个整数，而不是指向指向地址的下一个内存位置。也就是说程序的逻辑地址一般都不同于实际的物理地址。
　　如果有两个指向同一个数组的元素，那么我们可以通过这两个指针之间的算术运算得到一些有意义的表达式。比如，
　　intpointer;
　　intip＝pointer+i;
　　那么我们可以通过指ip－pointer得到i的值。如果ip和ponter指向的不是同一个元素，那么我们就无法保证这个操作的正确性，虽然他们在内存地址上相差一个整数倍。
　　让我们通过下面的一个例子来看看数组和指针操作的等效性和灵活度：
　　如果我们在程序中声明了以下两个语句，
　　inta【12】;
　　intp;
　　那么我们可以对数组和指针进行相应的操作了：
　　（1）p＝a;
　　因为a＝a【0】，所以这里就有p＝a【0】了，即p和a都指向数组的第一个元素；
　　（2）p＝p+1;
　　这也是正确的。它等效于p＝a;
　　（3）p++;
　　这个语句等效于p＝a;
　　还有：
　　p＝%26amp;a;这样的语句ansic中是错误的，这一点在前一篇文章我已经声明过，因为这两个操作数的类型很显然是不匹配的，即%26amp;a是一个指向数组的指针而p是一个整型指针。所以此类操作是非法的。有时可能会侥幸的通过（因为有些编译器提供商不一定严格的按照ansic的保准来开发自己的编译器），但是我们不提倡这种做法。
　　数组元素的引用
　　这是一个足够让人糊涂的问题。先看一看下面这个语句是否正确：
　　a+i＝a+i;
　　也许你会说很显然是正确的，因为它特别象一个两元加法运算。虽然答案的前一半是正确的，但是问题的实质可不是这样的。为了回答之一个问题我们需要从数组元素的引用说起。
　　在前面我们声明了a为一个拥有12个整型元素的数组，而且我们知道a是一个指向该数组的第一个（0位元素）元素的指针，所以按照指针的性质我们可以知道a就是对数组的第一个元素的引用。你可以通过如下的方式给数组的第一个元素赋值：
　　a＝2005;
　　明白了这一点，那么其他元素的赋值和引用也是类似的。（a+3）是对数组的弟3个元素的引用，而其赋值可以是：
　　（a+3）＝2006;
　　然而，由加法的交换律，可以知道1+a＝a+1，所以a+i＝i+a;
　　因为（a+i）＝（i+a）。
　　现在让我们想一想如何用指针来操作我们的二维数组吧。
　　前面我们声明了一个二维数组week，那么week代表什么意思呢？我想如果明白了前面的讲解，那么这个问题就一如反掌了。week代表的无非就是week数组的弟3个元素（数组下标从0开始），即一个拥有24个整型元素的数组。如果你还想知道week的内存大小，那么你可以通过sizeof操作来实现：
　　intmem;
　　mem＝sizeof（week）;
　　其实，sizeof（week）＝24sozeof（int）。
　　如果你想通过指针来访问week的元素（这里假设访问弟3个元素），那也是很简单的。请看下面的表达式：
　　intvalue;
　　p＝week;
　　C语言value＝（p+3）;
　　也可以是：
　　value＝week;
　　或者
　　value＝（week+3）;
　　还可以是：
　　value＝（（week+2）+3）；
　　由此我们可以看出来，数组和指针不是两个相互独立的结构，而是紧密紧密互不可分的整体。两者之间的互操作是最美的结合。我们提倡只在程序设计中才用数组和指针之间的互操作的实现方法。到这里我们的旅程也该结束了，如果说还有一些技术没有提及，我想那自然是数组和指针分别作为函数返回值类型和函数参数的情形罢了。其操作和上面提到的相当，在此就不提了。一般我们习惯于把指针当作函数返回值类型和函数参数来处理的，而不是处理数组，因为在这种情形下，对数组的操作显得很笨拙很底效。

本文转自 ☆★ 包罗万象网 ★☆ - http://www.baoluowanxiang.com 转载请注明出处，侵权必究！
原文链接：http://www.baoluowanxiang.com/a/program/c/2010/0910/1468.html