C++数组

1 数组的定义
数组是一个由若干同类型变量组成的集合。一维数组定义：
类型说明符 数组名[常量表达式]
在编译时，数组定义中的下标必须确定
例如：
const int size=50;
const int n=size*sizeof(int);
int main()
{
Int array[size];
char charray[n];
}

2访问数组元素

#include <iostream>
using namespace std;
void Fibonacci()
{
    int iArray[10];
    iArray[0]=1;
    iArray[1]=1;
    for (int i=2;i<10;i++)
    {
        iArray[i]=iArray[i-1]+iArray[i-2];
        cout<<iArray[i]<<endl;
    }
    cout<<iArray[9];
}

输入输出字符

void shuzu1()
{
    char chArray[10];
    cin.get(chArray,10);
    /*
    for (int i=0;chArray[i]!='\0';i++)
    {
        cout<<chArray[i];
    }
    */
    for (int i=0;i<10;i++)
    {
        cout<<chArray[i];
    }
    
    cout<<endl;
}

3 初始化数组

int array12[5]={1,2,3};
static int array2[5]={1};
void shuzu2()
{
    int arr1[5]={2};
    static int arr2[5]={1,2};
    int n;
    cout<<"global:\n";
    for (n=0;n<5;n++)
    {
        cout<<" "<<array12[n];
    }
    cout<<"\nglobal static :\n";
    for (n=0;n<5;n++)
    {
        cout<<" "<<array2[n];
    }
    cout<<"\nlocal :\n";
    for (n=0;n<5;n++)
    {
        cout<<" "<<arr1[n];
    }    
    cout<<"\nlocal static:\n";
    for (n=0;n<5;n++)
    {
        cout<<" "<<arr2[n];    
    }
    cout<<endl;
}

 初始化字符数组

void shuzu3()
{
    char arraych1[10]={"hello"};
    char arraych2[10]={'h','e','l','l','o','\n'};
    for (int n=0;arraych2[n]!='\0';n++)
    {
        cout<<arraych2[n];    
    }
}

 省略数组大小，有初始化的数组定义可以省略方括号中的数组大小 ，编译时必须知道数组的大小void shuzu4()

{
    //有初始化的数组定义可以省略方括号中的数组大小 ，编译时必须知道数组的大小
    static int a[] ={1,2,3,55,66,8,9,0};
    int n=sizeof(a)/sizeof(int);
    for (int i=0;i<n;i++)
    {
        cout<<a[i]<<endl;
    }    
}

 省略数组大小只能在初始化的数组定义中，

在定义数组的场合，无论如何，编译器必须知道数组的大小

#include<cstring>
void shuzu4()
{
    //有初始化的数组定义可以省略方括号中的数组大小 ，编译时必须知道数组的大小
    static int a[] ={1,2,3,55,66,8,9,0};
    int n=sizeof(a)/sizeof(int);
    for (int i=0;i<n;i++)
    {
        cout<<a[i]<<endl;
    }    
    //字符数组 数组大小为12，字符串长度为11 
    char ch[] ="How are you";
    cout<<"size of array:"<<sizeof(ch)<<endl;
    cout<<"size of string:"<<strlen(ch)<<endl;
     
}

 4 向函数传递数组

int sum(int array1[],int len) 
{
    int iSum=0;
    for (int i=0;i<len;i++)
    {
        iSum=iSum+array1[i];
    }
    return iSum;    
}
    
void shuzu5()
{
    //向函数传递数组,将数组作为参数传递给函数，实际上只是把数组地址传给函数
    //1传递给标准库函数
    /*
    函数原型 
    void memset ( void *s , char ch, unsigned n )
    函数功能：将s为首地址的一片连续的n个字节内存单元都赋值为ch
    memset(首地址,值,sizeof(地址总大小));
    */
    char a1[10];
    cout<<sizeof(char)<<endl;
    memset(a1, 'b', 10*sizeof(char));
    for (int i=0; i<10; i++) 
    {
        cout<<a1[i]<<endl;
    }
    //2传递给自定义函数    
    static int ia[5]={2,3,4,45,11};
    int sumofarray;
    sumofarray=sum(ia,sizeof(ia)/sizeof(int));
    cout<<sumofarray<<endl;     
    //3 
}

 程序也可以这么写

int sum(int array1[],int len) 
{
    int iSum=0;
    for (int i=0;i<len;i++)
    {
        iSum=iSum+array1[i];
    }
    array1[len]=iSum;
    return 0;    
}
    
void shuzu5()
{
    //向函数传递数组,将数组作为参数传递给函数，实际上只是把数组地址传给函数
    //1传递给标准库函数
    /*
    函数原型 
    void memset ( void *s , char ch, unsigned n )
    函数功能：将s为首地址的一片连续的n个字节内存单元都赋值为ch
    memset(首地址,值,sizeof(地址总大小));
    */
    char a1[10];
    cout<<sizeof(char)<<endl;
    memset(a1, 'b', 10*sizeof(char));
    for (int i=0; i<10; i++) 
    {
        cout<<a1[i]<<endl;
    }
    //2传递给自定义函数    
    static int ia[6]={2,3,4,45,11};
    int sumofarray;
    sumofarray=sum(ia,sizeof(ia)/sizeof(int));
    cout<<ia[6]<<endl;     

}

 5 二维数组

void shuzu6() 
{
    int array1[2][3]={1,2,3,4,5};
    int array2[2][3]={{1,2},{3}};        
    int i,j;
    for (i=0;i<2;i++)
    {
        for (j=0;j<3;j++)
        {
            cout<<array1[i][j]<<",";
        }
        cout<<endl;
    }
    cout<<endl;
    for (i=0;i<2;i++)
    {
        for (j=0;j<3;j++)
        {
            cout<<array2[i][j]<<",";
        }
        cout<<endl;
    }
}

 

省略第一维大小
int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
下面代码等价的：
int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

int a[][4]={{1,2,3},{},{4,5}};
下面代码等价的：
int a[3][4]={{1,2,3},{0,0,0},{4,5,0}};

 作为参数传递一个二维数组给函数，其意义也为内存地址

int maximum(int grade[][4],int pupils,int tests)
{
    int max=0;
    for (int i=0;i<pupils;i++)
    {
        for (int j=0;j<tests;j++) 
        {
            if (grade[i][j]>max)
            {
                max=grade[i][j];
            }
        }
    }
    return max;
}
void shuzu7() 
{
    //二维数组作为参数传递
    int sg[3][4]={
    {68,77,73,86},
    {87,96,78,89},
    {90,70,81,86}
    };
    cout<<maximum(sg,3,4)<<endl;
        
}

 二维数组 降维处理

 

int maximum(int grade[],int num)
{
    int max=0;
    for (int i=0;i<num;i++)
    {
        if (grade[i]>max)
        {
            max=grade[i];
        }
    }
    return max;    
}
void shuzu7() 
{
    //二维数组作为参数传递
    int sg[3][4]={
    {68,77,73,86},
    {87,96,78,89},
    {90,70,81,86}
    };
    cout<<maximum(&sg[0][0],3*4)<<endl;
        
}

 6 Josephus问题

/*
Josephus问题： 
约瑟夫问题，是一个计算机科学和数学中的问题，在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。
*/
void shuzu8() 
{
    //建立小孩组 
    const int num=10; //小孩数 
    int interval;     //每次数interval个小孩，便让小孩离开
    int a[num] ;//小孩数组
    //给小孩编号
    for (int i=0;i<num;i++) 
    {
        a[i]=i+1;
    }
    //输入小孩间隔
    cout<<"please input the interval:" ;
    cin>>interval;
    //将全体参加的小孩输出
    for (int i=0;i<num;i++) 
    {
        cout<<a[i]<<",";
    }
    cout<<endl;
    int k=1;//标识处理第k个离开的小孩
    int i=-1;//数组下标（下一个值0就是第一个小孩的下标）    
    //处理提前获胜的小孩
    while (1) 
    {
        //在圈中数interval个小孩
        for (int j=0;j<interval;) 
        {
            i=(i+1)%num;//对下标加1求模 
            if (a[i]!=0) //如果该元素的小孩在圈中，则承认数数有效 
            {
                j++;
            }
        }
        if (k==num) break; //该小孩是最后一个(胜利者)吗 ?
        cout<<a[i]<<",";
        a[i]=0;//输出离开小孩之编号 
        k++;//标识该小孩已离开                         
    }
    //break语句跳转到此
    cout<<"\nNo:" <<a[i]<<"boy've won.\n";//输出胜利者 
}

运行结果