|
Хочу получить удостоверение. Сколько стоит оплата? |
Инспектор
Вы можете этот курс.
Опубликован: 10.12.2015 | Уровень: для всех | Доступ: платный
Лекция 7:
Одномерные массивы
< Лекция 6 || Лекция 7 || Лекция 8 >
Ключевые слова: доступ, индекс, адрес, define, интерполяция, double, компилятор, сообщение об ошибке, char
Массивами являются переменные, содержащие несколько элементов одного типа. Доступ к отдельному элементу осуществляется с помощью его индекса. Элементы массива располагаются в памяти компьютера последовательно, и индекс первого элемента равен нулю. Имя массива является постоянным значением, представляющим собой адрес первого элемента.
Для того чтобы работать с элементами массива нужно в начале его объявить (задать тип составляющих его элементов), а затем инициализировать его, т.е. присвоить элементам массива определенные значения.
Рассмотрим несколько вариантов определения и инициализации массивов. В первом случае с помощью директив препроцессора #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 >
