初始化int类型数组data1[ ]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20}先使用任意一种算法对其排序提示用户输入一个数字，应用折半查找函数模板找出它的位置。
 
  #include <iostream>
  using namespace std;
  template<class T>
   //这里使用了冒泡法排序：
  void mySwap(T&x, T&y)//交换x，y的值
  {
      T temp = x;
    	x = y;
    	y = temp;
   }
    
    template<class T>
    void bubblesort(T a[], int n)//用冒泡法对数组a的n个元素进行排序
    {
	int i = n - 1;

	while (i > 0)
	{
		int lastExchangeIndex = 0;
		for (int j = 0; j < i; j++)
		    if (a[j+1]<a[j])
		{     
				mySwap(a[j], a[j + 1]);
				lastExchangeIndex = j;
		}
		i = lastExchangeIndex;
	}  
}

template<class T>
int BinSearch(const T list[], int n, const T key)//用折半查找法，在元素呈升序排列的数组list中查找值为key的元素
{

	int low = 0;
	int high = n - 1;
	while (low <= high)
	{
		int mid = (low + high) / 2;
	
		if (key == list[mid])
			return mid;
		else if (key>list[mid])
			low = mid + 1;
		else
			high = mid - 1;
	}
	return -1;
}


int main()
{
	int key, mid, n = 20;
	int i;
	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
	cout << "数组排序后:" << endl;
	 bubblesort(data1, n);
	 for ( i = 0; i < 20; i++)
	 {
		 cout << data1[i]<<",";
	 }
	 cout << endl;
	 cout << "请输入key:" << endl;
	cin >> key;
	cout << key <<"在数组第："<<BinSearch(data1, n, key)+1 <<"个数字"<< endl;//数组首元素从1开始算起
}
 

初始化 int 类型数组 data 1 []={1，3，5，7，9，11，13，15，17，19，2，4，6，8，10，12，14，16，18，20} ，先用任意一种算法对其进行排序，然后提示用户输入一个数字，应用本章的折半查找函数模板找出它的位置。
 
#include<iostream>

using namespace std;

template<class T>

void BubbleSort(T list[], int n)
{
	for (int i = 0; i < n - 1; i++)  //冒泡
	{
		int t;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (list[j] > list[j + 1])
			{
				t = list[j];
				list[j] = list[j + 1];
				list[j + 1] = t;
			}
		}
	}
}

template<class T>

int binSearch(T list[], int n, T key)
{
	int begin, mid, end;
	begin = 0;
	end = n - 1;
	while (begin <= end)
	{
		mid = (begin + end) / 2;
		if (key == list[mid])
			return mid;
		else if (key > list[mid])
			begin = mid + 1;
		else
			end = mid - 1;
	}
	return -1;
}

int main()
{
	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
	int key, n = 20;

	BubbleSort(data1, n);     //冒泡
	
cout << "排序后的数组为：" << endl;
	for (int i = 0; i < n; i++)
	{
		cout << data1[i] << "  ";
	}

	cout << endl;
	cout << "请输入所要查找的数字：";
	cin >> key;
	cout << "在数组中的位置："<<binSearch(data1, n, key) << endl;
}
 
上一篇：用函数模板方式设计一个函数模板Sort

 
c语言中初始化一个数组
 

  

  

 
 
In this article, we’ll take a look at how we will initialize an array in C.
 
 在本文中，我们将研究如何在C中初始化数组。 
 
 
There are different ways through which we can do this, so we’ll list them all one by one. Let’s get started!
 
 我们可以通过多种方式来做到这一点，因此我们将它们一一列出。 让我们开始吧！ 
 
 

 
 
 

 
 
 
 方法1：使用初始化列表初始化数组 (Method 1: Initialize an array using an Initializer List)
 
 
An initializer list initializes elements of an array in the order of the list.
 
 初始化列表按列表的顺序初始化数组的元素。 
 
 
For example, consider the below snippet:
 
 例如，考虑以下代码片段： 
 
 

int arr[5] = {1, 2, 3, 4, 5};

 
This initializes an array of size 5, with the elements {1, 2, 3, 4, 5} in order.
 
 这将初始化一个大小为5的数组，其中元素{1、2、3、4、5}顺序排列。 
 
 
This means that arr[0] = 1, arr[1] = 2, and so on.
 
 这意味着arr[0] = 1 ， arr[1] = 2 ，依此类推。 
 
 

  

  

 
 
We don’t need to initialize all the elements 0 to 4. We can even do only from indices 0 to 2.
 
 我们不需要初始化所有元素0到4。我们甚至只能对索引0到2进行初始化。 
 
 
The following code is also valid:
 
 以下代码也是有效的： 
 
 

int arr[5] = {1, 2, 3};

 
But now, arr[4] and arr[5] will still remain garbage values, so you need to be careful!
 
 但是现在， arr[4]和arr[5]仍将是垃圾值，因此您需要小心！ 
 
 
If you’re using an initializer list with all elements, you don’t need to mention the size of the array.
 
 如果您正在使用包含所有元素的初始化列表，则无需提及数组的大小。 
 
 

// Valid. Size of the array is taken as the number of elements
// in the initializer list (5)
int arr[] = {1, 2, 3, 4, 5};

// Also valid. But here, size of a is 3
int a[] = {1, 2, 3};

 
If you want to initialize all the elements to 0, there is a shortcut for this (Only for 0). We can simply mention the index as 0.
 
 如果要将所有元素初始化为0，则有一个快捷方式（仅适用于0）。 我们可以简单地将索引称为0。 
 
 

#include <stdio.h>

int main() {
    // You must mention the size of the array, if you want more than one
    // element initialized to 0
    // Here, all 5 elements are set to 0!
    int arr[5] = {0};
    for (int i=0; i<5; i++) {
        printf("%d\n", arr[i]);
    }
    return 0;
}

 
Output
 
 输出量 
 
 

0
0
0
0
0

 
If you’re using multi-dimensional arrays, you can still initialize them all in one block, since arrays are stored in a row-wise manner.
 
 如果您使用的是多维数组，由于数组是以行方式存储的，因此仍然可以在一个块中将它们全部初始化。 
 
 

#include <stdio.h>

int main() {
    int arr[3][3] = {1,2,3,4,5,6,7,8,9};
    for (int i=0; i<3; i++)
        for (int j=0; j<3; j++)
            printf("%d\n", arr[i][j]);
    return 0;
}

 
Output
 
 输出量 
 
 

  

  

 
 

1
2
3
4
5
6
7
8
9

 
A similar method can also be used for other datatypes, like float, char, char*, etc.
 
 类似的方法也可以用于其他数据类型，例如float ， char ， char*等。 
 
 

#include <stdio.h>

int main() {
    // Array of char* elements (C "strings")
    char* arr[9] = { "Hello", [1 ... 7] = "JournalDev", "Hi" };
    for (int i=0; i<9; i++)
        printf("%s\n", arr[i]);
    return 0;
}

 
Output
 
 输出量 
 
 

Hello
JournalDev
JournalDev
JournalDev
JournalDev
JournalDev
JournalDev
JournalDev
Hi

 
Remember, this method with [1 … 7] = “Journaldev” might not work with all compilers. I work on GCC in Linux.
 
 请记住，这种[1…7] =“ Journaldev”的方法可能不适用于所有编译器。 我在Linux上开发GCC。 
 
 
 方法2：使用for循环在C中初始化数组 (Method 2: Initialize an array in C using a for loop)
 
 
We can also use the for loop to set the elements of an array.
 
 我们还可以使用for循环来设置数组的元素。 
 
 

#include <stdio.h>

int main() {
    // Declare the array
    int arr[5];
    for (int i=0; i<5; i++)
        arr[i] = i;

    for (int i=0; i<5; i++)
        printf("%d\n", arr[i]);

    return 0;
}

 
Output
 
 输出量 
 
 

0
1
2
3
4

 
 方法3：使用指定的初始化程序（仅对于gcc编译器） (Method 3: Using Designated Initializers (For gcc compiler only))
 
 
If you’re using gcc as your C compiler, you can use designated initializers, to set a specific range of the array to the same value.
 
 如果将gcc用作C编译器，则可以使用指定的初始化程序将数组的特定范围设置为相同的值。 
 
 

// Valid only for gcc based compilers
// Use a designated initializer on the range
int arr[9] = { [0 ... 8] = 10 };

 
Note that there is a space between the numbers and there are the three dots. Otherwise, the compiler may think that it is a decimal point and throw an error.
 
 请注意，数字之间有一个空格，并且有三个点。 否则，编译器可能会认为这是一个小数点并抛出错误。 
 
 

#include <stdio.h>

int main() {
    int arr[9] = { [0 ... 8] = 10 };
    for (int i=0; i<9; i++)
        printf("%d\n", arr[i]);
    return 0;
}

 
Output (for gcc only)
 
 输出（仅适用于gcc） 
 
 

10
10
10
10
10
10
10
10
10

 
We can also combine this with our old initializer list elements!
 
 我们也可以将其与旧的初始化列表元素结合起来！ 
 
 
For example, I am setting only array index arr[0], arr[8] as 0, while the others are designated initialized to 10!
 
 例如，我仅将数组索引arr[0], arr[8]为0，而将其他数组都初始化为10！ 
 
 

#include <stdio.h>

int main() {
    int arr[9] = { 0, [1 ... 7] = 10, 0 };
    for (int i=0; i<9; i++)
        printf("%d\n", arr[i]);
    return 0;
}

 
Output
 
 输出量 
 
 

0
10
10
10
10
10
10
10
0

 

 
 
 
 结论 (Conclusion)
 
 
In this article, we learned how we could initialize a C array, using different methods.
 
 在本文中，我们学习了如何使用不同的方法初始化C数组。 
 
 
For similar articles, do go through our tutorial section on C programming!
 
 对于类似的文章，请阅读我们有关C编程的教程部分 ！ 
 
 

 
 
 

  
翻译自: https://www.journaldev.com/39020/initialize-an-array-in-c
 
 
c语言中初始化一个数组

渣渣c的c语言学习之路
 
1.关于c语言的结构体:
 
首先我们为什么要用到结构体，我们都已经学了很多int char …等类型还学到了同类型元素构成的数组，以及取上述类型的指针，在一些小应用可以灵活使用，然而，在我们实际应用中，每一种变量进行一次声明，再结合起来显然是不太实际的，类如一位学生的信息管理，他可能有，姓名（char），学号（int）成绩（float）等多种数据。如果把这些数据分别单独定义，就会特别松散、复杂，难以规划，因此我们需要把一些相关的变量组合起来，以一个整体形式对对象进行描述，这就是结构体的好处。
 
 2首先我们要了解一些小知识
 
2.1**只有结构体变量才分配地址，而结构体的定义是不分配空间的。**
 2.2结构体中各成员的定义和之前的变量定义一样，但在定义时也不分配空间。
 2.3结构体变量的声明需要在主函数之上或者主函数中声明，如果在主函数之下则会报错
 2.4c语言中的结构体不能直接进行强制转换，只有结构体指针才能进行强制转换
 2.5相同类型的成员是可以定义在同一类型下的
 列如
 

struct Student
{ 
	int number,age；//int型学号和年龄
	char name[20],sex;//char类型姓名和性别
	float score;
}；
 
最后的分号不要忘了 有的编译器会自动加上，因此有的同学就会不注意。
 
 3关于结构体变量的定义和引用
 
在编译时，结构体的定义并不分配存储空间，对结构体变量才按其数据结构分配相应的存储空间
 

 struct Book
 { 
 	char title[20];//一个字符串表

示的titile 题目
	char author[20];//一个字符串表示的author作者
 	float value;//价格表示 
 };//这里只是声明 结构体的定义 
struct Book book1,book2;//结构体变量的定义 分配空间

book1.value;//引用结构体变量
 
定义结构体变量以后，系统就会为其分配内存单元，比如book1和book2在内存中占44个字节（20+20+4）具体的长度你可以在你的编译器中使用sizeof关键字分别求出来。
 列如
 
 当然，要注意一点：用sizeof关键字求结构体长度时，返回的最大基本类型所占字节的整数倍 比方说我们上面求得的为44 为 float(4个字节)的整数倍，
 但是我们把title修改为title[22]; 这时正常长度为46 ，但是你会发现实际求得的为48，(4的整数倍)
 
这就涉及到结构体的存储：
 
1结构体整体空间是占用空间最大的成员（的类型）所占字节数的整数倍。
 
2.结构体的每个成员相对结构体首地址的偏移量(offset)都是最大基本类型成员字节大小的整数倍，如果不是编译器会自动补齐，
 
关于这个我们简单介绍下：
 
1.偏移量----偏移量指的是结构体变量中成员的地址和结构体变量首地址的差。即偏移字节数，结构体大小等于最后一个成员的偏移量加上他的大小，第一个成员的偏移量为0，
 
struct S1
{
    char a;

    int b;

    double c;
};
 
这里char a 偏移量为1 之后为int b 因为偏移量1不为int(4)的整数倍，所以会自动补齐，而在 double c 时，偏移量为8 是double(8)的整数倍，所以不用自动补齐 最后求得结构体得大小为 16
 
具体看下图：
 
 通过上面的代码同学们应该会有一个简单的认知
 
 4结构体变量的初始化
 
结构体的初始化有很多需要注意的地方，这里我们说明下
 首先是几种初始化的方法
 ps：在对结构体变量初始化时，要对结构体成员一一赋值，不能跳过前面成员变量，而直接给后面成员赋初值，但是可以只赋值前面几个，对与后面未赋值的变量，如果是数值型，则会自动赋值为0,对于字符型，会自动赋初值为NULL，即‘\0’
 
 4.1定义时直接赋值
 
struct Student
{ 
	char name[20];
	char sex;
	int number;
}stu1={"zhaozixuan",'M',12345};
//或者
struct Student
{ 
	char name[20];
	char sex;
	int number;
}；
struct Student stu1={"zhaozixuan",'M',12345};

 
注意字符为‘ ’ 字符串为""
 4.2定义结构体之后逐个赋值
 
stu1.name="王伟"；
stu1.sex='M';
stu1.number=12305;
//也可用strcpy函数进行赋值
strcpy(stu1.name,"王伟");

 
4.3定义之后任意赋值
 
 struct Student stu1={
  .name="Wang",
  .number=12345,
  .sex='W', 
 };//可以对任意变量赋值
 
这样写的好处时不用按照顺序来进行初始化，而且可以对你想要赋值的变量直接进行赋值，而不想赋值的变量可以不用赋值
 
需要注意的是如果在定义结构体变量的时候没有初始化，那么后面就不能全部一起初始化了；
 
等下结构体数组初始化时我们还会有一个讲解
 
这里我们顺带提一下typedef说明结构体类型
 

 这里的BOOK就相当于struct book的一个别名一样，用它来定义结构体变量非常简便
 主要也是考二级要用到，所以我们简单介绍下
 
 5结构体变量的引用（输出和输入）
 
5.1结构体变量的赋值用scanf赋值和printf输出时跟其他变量操作一样
 但是有几点需要注意
 (1) .是运算符，在所有运算符优先级中最高
 (2)如果结构体的成员本身是一个结构体，则需要继续用.运算符，直到最低一级的成员。
 
struct Student
{	char name[20];
	char sex;
	int number;
	struct Date
	{
		int year;
 		int month;
 		int day;
	}birthday;

}stu1;
printf("%d",stu1.birthday);//这样子是错误的，因为birthday也是一个结构体变量
scanf("%d",&stu1.birthday.month);//正确
 
(3)可以引用接头体变量成员的地址，也可以引用结构体变量的地址：
 
printf("%o", student);(输出student的首地址)(%o 按八进制输出)
 
 6结构体数组及其初始化(重点)
 
这里我们简单说下，具有相同类型的结构体变量组成数组就是结构体数组
 
结构体数组与结构体变量区别只是将结构体变量替换为数组
 
struct Student
{ 
	char name[20];
	char sex;
	int number;
}stu1[5]={
	 {"zhaozixuan",'M',12345},
	 {"houxiaohong",'M',12306},
	 {"qxiaoxin",'W',12546},
	 {"wangwei",'M',14679},
	 {"yulongjiao",'W',17857}
};
stu1[3].name[3]//表示stu1的第三个结构变量中姓名的第五个字符
//若初始化时已经是结构体数组全部元素[]中的数可以不写如stu1[]=
 
注意结构体数组要在定义时就直接初始化，如果先定义再赋初值是错误的
 比如：
 
struct Student stu1；
stu1[3]={
  {"zhaozixuan",'M',12345},
  {"houxiaohong",'M',12306},
  {"qxiaoxin",'W',12546}
  };
  
 
这样子是错误的，
 
这里我在写的时候遇到一些问题，还是结构体数组初始化的问题，折腾了下解决了，给大家分享下
 对于数组初始化时
 比如
 
char str[20];
str="I love you";/* 这样会修改数组的地址，但是数组的地址分配之后是不允许改变的 */

 
在第一条语句中 str就已经被定义成数组而在C99标准中不允许将字符串(实际上是一个指针变量) 赋值给数组，所以如果我们直接赋值是错误的
 
那么怎么弄呢
 这里提供3种方法
 
1.定义数组时直接定义
 char str[20]=“I love you”;
 
2.用strcpy或者memset函数进行复制
 char str[20];
 strcpy(str,“I love you”);
 再用到memset函数时，出现了一些问题
 对于memcset函数简单介绍下
 
memset
 void *memset(void *s,int c,size_t n)
 作用：将已开辟内存空间s的首n个字节的值设为值c。
 
char str[20];
memset(str,'a',20);
 
如果是字符类型数组的话，memset可以随便用，但是对于其他类型的数组，一般只用来清0或者填-1，如果是填充其他数据就会出错
 
int str[10];
memset(str,1,sizeof(str));//这样是错误的

 
这里我们说下这个错误，
 
首先我们要知道memset在进行赋值时，是按字节为单位来进行赋值的，每次填充的数据长度为一个字节，而对于其他类型的变量，比如int，占4个字节 所以sizeof(str)=40； 而用memset赋值时，将会对指向str地址的前40个字节进行赋值0x01（00000001） 的操作，把0x00000000赋值4次0x01操作变为0x01010101（00000001000000010000000100000001）
 
相当于给“前10个int”进行了赋值0x01010101的操作 对应十进制的16843009
 所以会出很大的错误
 
 
这里请务必要注意，但是如果是清零一个数组用memset还是很方便的
 简单使用的话同学们用strcmp函数就行
 
3用指针（注意内存分配）
 char *str；
 str=“I love you”;
 
 
 
这两句话的本质是，在内存中开辟一段内存空间，把"I love you"放进这段内存空间，然后把这段内存空间的地址交给str，由于str是变量，所以给它赋值是合法的。
 
 
请注意，在我们进行数组初始化的时候如果定义的数组过长，而我们只初始化了一部分数据，对于未初始化的数据如果是数值型，则会自动赋值为0,对于字符型，会自动赋初值为NULL，即‘\0’ 即不足的元素补以默认值
 这里我们在4小节中也提到了
 比如
 
int str[10]={1};//这里只是把str的第一个元素赋值为1，其他元素默认为0

 

 
 7结构体与指针
 
我们知道，指针指向的是变量所占内存的首地址，在结构体中，指针指向的是结构体变量的起始地址，当然也可指向结构体变量的元素
 这里我们分为三部分
 7.1指向结构体变量的指针
 
定义形式一般为
 struct 结构体名* 指针名；
 比如： struct Student* p；
 
struct Student
{	
	char cName[20];
 	int number;
 	char csex;  
}student1;
struct Student*p;
p=&student1;
//若为结构体数组则
struct Student stu1[5];
struct Student*p;
p=stu1;//因为stu1为结构体数组而p=stu1直接是指向stu1的首地址，就不用再加&符

 
用结构体指针变量访问结构体变量成员有以下两种方式：
 (*p).cName //这里的括号不能少，在5.1中有提到
 p->cName
 
简单来说以下三种形式是等价的
 
p->cName
(*p).cName 
student1.cName
p->cName //可以进行正常的运算
 
p->number++; 是将结构体变量中number的值进行运算，然后再加一，
 这里要注意下，等下在7.2中会有比较
 
7.2指向结构体数组的指针
 
7.1中我们已经提到结构体数组指针的命名，这里我们仅对一些知识点做下介绍
 这里我们接着来说结构体数组指针
 在我们想要用指针访问结构体数组的第n个数据时可以用
 
struct Student stu1[5];
struct Student*p;
p=stu[n];
(++p).number//是指向了结构体数组下一个元素的地址

 
7.3结构体成员是指针类型变量
 比如
 
struct Student
{
 	char* Name;//这样防止名字长短不一造成空间的浪费
 	int number;
 	char csex;  
}student1;

 
在使用时可以很好地防止内存被浪费，但是注意在引用时一定要给指针变量分配地址，如果你不分配地址，结果可能是对的，但是Name会被分配到任意的一的地址，结构体不为字符串分配任何内存存储空间具有不确定性，这样就存在潜在的危险，
 
struct Student
{
 	char* Name;
 	int number;
 	char csex;  
}stu，*stu；

stu.name=(char*)malloc(sizeof(char));//内存初始化
 
这里我们说一下，同学们看书的时候一般不会看到，
 如果我们定义了结构体指针变量，他没有指向一个结构体，那么这个结构体指针也是要分配内存初始化的，他所对应的指针类型结构体成员也要相应初始化分配内存
 
struct Student
{
 	char* Name;
 	int number;
	char csex;  
}stu,*stu;
stu = (struct student*)malloc(sizeof(struct student));./*结构体指针初始化*/
  stu->name = (char*)malloc(sizeof(char));/*结构体指针的成员指针同样需要初始化*/  

 
7.4二叉树遍历算法
 二叉树的二叉链表类型定义如下：
 typedef struct btnode {
 datatype data;
 struct btnode *lchild,*rchild;
 }；
 这里我们仅仅提出以下，因为涉及到链表，感兴趣的同学可以去学习下（二级要用），
 7.5结构体作为函数参数
 
首先我们要注意的一点，使用结构体变量作为函数参数的时候，采取的是值传递的方式，将结构体所占内存单元的内容全部传递给形参，并且形参必须也要是同类型的结构体变量，在使用时，会自动创建一个结构体变量作为原变量的副本，并且也需要占内存，并且在调用期间如果修改（形参）结构体中成员的值，修改值是无效的，
 
 
而如果用指针作为实参，传递给函数的形参，这时候传递的是结构体的地址，形参所指向的地址就是结构体变量的地址，这时候进行修改的话是可以修改的，这正是指针的精华所在
 
 
在这里我们再提供几种互换两个结构体的方法
 
struct Student
{
 char cName[20];
 int number;
 char csex;  
}student1,student2;
struct Student student1={"Wang",12345,'W'};
struct Student student2={"Zhao",54321,'M'}; 
struct Student*stu1=&student1;
struct Student*stu2=&student2;

struct Student *student3;
student3=stu1;
stu1=stu2;
stu2=student3;//互换地址

2对于同类型结构体直接互换值就行
struct stu student3;
student3=student1;
student1=student2;
student2=student3;
//这里也可以写成应strcmp函数互换

3用memcpy()函数进行互换


4比较笨的方法： 用for循环互换
 
最后提下memset清空结构体
 
struct Student
{
 char cName[20];
 int number;
 char csex;  
}stu1;

一般情况下，清空str的方法：
　　str.cName[0]='\0';
　　str.csex='0';
　　str.number=0;
　　但是我们用memset就非常方便：
　　memset(&str,0,sizeof(struct Student));
　　如果是数组：
　　struct Student stu[10];
　　就是
　　memset(stu,0,sizeof(struct Student)*10);
 
整理不易，点个赞再走呗！