Опубликован: 10.12.2015 | Уровень: для всех | Доступ: платный
Лекция 7:

Одномерные массивы

< Лекция 6 || Лекция 7 || Лекция 8 >

Массивами являются переменные, содержащие несколько элементов одного типа. Доступ к отдельному элементу осуществляется с помощью его индекса. Элементы массива располагаются в памяти компьютера последовательно, и индекс первого элемента равен нулю. Имя массива является постоянным значением, представляющим собой адрес первого элемента.

Для того чтобы работать с элементами массива нужно в начале его объявить (задать тип составляющих его элементов), а затем инициализировать его, т.е. присвоить элементам массива определенные значения.

Рассмотрим несколько вариантов определения и инициализации массивов. В первом случае с помощью директив препроцессора #define определяется размер массивов, затем указывается тип их элементов, после чего уже инициализируются элементы.

В приводимой ниже программе производится интерполяция функции методом Лагранжа.

//==========================================================
// Name        : lagrange_interpolation.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;

//Размер массива
#define array_size 5

int main() {
	double x[array_size], y[array_size];
	int i,k;
	double z;   //Вводимое значение X
	double p;   //
	double g;   //Интерполируемое значение Y

	for(i=0;i<array_size;i++)
	{
		cout<<"\nx["<<i+1<<"] = "; cin>>x[i];
		cout<<"\ny["<<i+1<<"] = "; cin>>y[i];
	}

	cout<<"\nFor what X value do you want calculate Y one? So, X = ";
	cin>>z;

	g=0;

	for(k=0;k<array_size;k++)
	{
		p=1;
		for(i=0;i<array_size;i++)
		{
			if(i==k) goto alpha;
			p*=(z-x[i])/(x[k]-x[i]);
	alpha:;	}
		g+=p*y[k];
	}
	cout<<"\nX = "<<z<<", Y = "<<g<<endl;
	return 0;
}

Результат:

x[1]=0
y[1]=0
x[2]=1
y[2]=1
x[3]=2
y[3]=4
x[4]=3
y[4]=9
x[5]=4
y[5]=16
For what X value do you want to calculate Y one? So, X = 2.5
X=2.5, Y=6.25

Рассмотрим другие способы определения и инициализации массивов.

//==========================================================
// Name        : array_properties_1.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================
#include <iostream>
using namespace std;

int main() {
	//Одновременно с заданием типа элементов массива
	//происходит и инициализация элементов

		double d[5]={1.2, 6.4, -8, 0.378, 5.6};

		for(int i=0;i<5;i++)
		{
			cout<<"\nd ["<<i+1<<"] = "<<d[i];
		}

		cout<<"\n"<<endl;

	//Количество элементов массива заранее не известно
		char country[]="Russia";

	//Определим количество элементов символьного массива
	//В связи с тем, что в конце строки
	//ставится символ '\0' вычитаем единицу

		int n=sizeof(country)/sizeof(country[0])-1;

		for(int i=0;i<n;i++)
		{
		cout<<"\ncountry ["<<i+1<<"] = "<<country[i];
		}

		cout<<"\n"<<endl;
	return 0;
}

Результат:

d [1] = 1.2
d [2] = 6.4
d [3] = -8
d [4] = 0.378
d [5] = 5.6

country [1] = R
country [2] = u
country [3] = s
country [4] = s
country [5] = i
country [6] = a

В первом случае мы явно указываем количество элементов массива (5), а также их тип (double), а затем присваиваем элементам значения (числа в фигурных скобках, разделенные запятой). При этом очень важно, чтобы количество элементов массива, находящихся в скобках не превышало заданный размер массива (иначе компилятор выдаст сообщение об ошибке).

Во втором случае мы заранее не знаем количество элементов символьного массива и пишем char country[] (country – имя массива). Для того чтобы найти количество элементов этого массива используем функцию sizeof().

Функция sizeof()

Эта функция используется двояко. С одной стороны с ее помощью можно определять размер памяти (количество байт), выделяемых под одну переменную определенного типа, например так: sizeof(int). С другой стороны, можно определять объем памяти, выделяемый под весь массив: sizeof(имя_массива), или под какой-либо из его элементов: sizeof(имя_массива[i]).

//==========================================================
// Name        : size_of.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;

int main() {
	cout<<"\nsizeof(char)         = "<<sizeof(char);
	//символьный
	cout<<"\nsizeof(short)        = "<<sizeof(short);
	//короткое целое
	cout<<"\nsizeof(int)          = "<<sizeof(int);
	//целое
	cout<<"\nsizeof(long)         = "<<sizeof(long);
	//длинное целое
	cout<<"\nsizeof(float)        = "<<sizeof(float);
	//вещественное
	cout<<"\nsizeof(double)       = "<<sizeof(double);
	//вещественное двойной точности
	cout<<"\nsizeof(long double)  = "<<sizeof(long double);
	//длинное вещественное двойной точности

	cout<<"\n"<<endl;
	double a[]={1.35, 6.12, -.6389, 41.4};
	int b=sizeof(a);
	//Количество байт, отводимых под массив
	int c=sizeof(a[0]);
	//Количество байт, отводимых под первый элемент
	int n=b/c;
	//Размер массива

cout<<"\nTotal memory, allocated to array       = "<<b;
cout<<"\nMemory, allocated to first arrays member = "<<c;
	cout<<"\nArray's size                          = "<<n;

	cout<<"\n"<<endl;
	return 0;
}

Результат:

sizeof(char)         = 1
sizeof(short)        = 2
sizeof(int)          = 4
sizeof(long)         = 4
sizeof(float)        = 4
sizeof(double)       = 8
sizeof(long double)  =8

Total memory, allocated to array         = 32
Memory, allocated to first arrays member = 8
Array's size                             = 4

Если мы, предположим, объявили целочисленный массив из десяти элементов, а сами указали только пять, то оставшиеся 5 элементов этого массива будут пустыми (это вполне нормально):

//==========================================================
// Name        : array_properties_2.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;

int main() {
	int a[10]={1, 4, 5, 8, 9};
		for(int i=0;i<10;i++)
		{
			cout<<"\na["<<i<<"] = "<<a[i];
		}
	cout<<"\n"<<endl;
	return 0;
}

Результат:

a [0] = 1
a [1] = 4
a [2] = 5
a [3] = 8
a [4] = 9
a [5] = 0
a [6] = 0
a [7] = 0
a [8] = 0
a [9] = 0

В следующем примере решения уравнения линейной регрессии с помощью функции sizeof определяется размер массивов.

//==========================================================
// Name        : linear_regression.cpp
// Author      : Marat
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//==========================================================

#include <iostream>
using namespace std;
#include<math.h>
//Решение уравнения линейной регрессии
//y=ax+b

int main() {
	double x[]={0, 0.9, 1.98, 3.05, 4.2, 5.02, 6.3};
	double y[]={1, 3.1, 4.8,  7.2,  8.9, 11.5, 12.7};
	int n=sizeof(x)/sizeof(x[0]);

	double s1=n;
	double s2=0;
	double s3=0;
	double s4=0;
	double s5=0;

	for(int i=0;i<n;i++)
	{
		s2+=x[i];
		s3+=y[i];
		s4+=pow(x[i],2);
		s5+=y[i]*x[i];
	}

double d1=s1*s4-pow(s2,2);
double d2=s3*s4-s5*s2;
double d3=s1*s5-s2*s3;

double a=d2/d1;
double b=d3/d1;


for(int i=0;i<n;i++)
{
cout<<"\nx["<<i<<"] = "<<x[i]<<"\t        y["<<i<<"] = "<<y[i];
}
cout<<"\nRegression equation is following ";
cout<<"\nY = "<<a<<" + "<<b<<"*x ";
double s=0;
for(int i=0;i<n;i++)
{
	s+=pow((y[i]-(a+b*x[i])),2);
}

cout<<"\nSum of square deviations is "<<s<<endl;
	return 0;
}

Результат:

x[0]=0     y[0]=1
x[1]=0.9   y[1]=3.1
x[2]=1.98  y[2]=4.8
x[3]=3.05  y[3]=7.2
x[4]=4.2   y[4]=8.9
x[5]=5.02  y[5]=11.5
x[6]=6.3   y[6]=12.7
Regression equation is following
Y=1.20386+1.90084*X
Sum of square deviations is 1.204
< Лекция 6 || Лекция 7 || Лекция 8 >
Зося Ковалева
Зося Ковалева

Хочу получить удостоверение. Сколько стоит оплата?