Прокомментировать код

// x.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include "stdafx.h"
#include "iostream"
using namespace std;
 
class massiv {public:
int n, *S;
massiv (int =5);
void vvod();
void vuvod();
int max();
int min();
void sort();
};
 
massiv::massiv (int nn)
{ n=nn;
S=new int [n];
}
 
void massiv::vvod()
{
    cout<<"Введите количество элементов массива: ";
    cin>>n;
    for (int i=0;i<n;i++)
    {
        cout<<"\n S["<<i<<"]=";
        cin>>S[i];
    }
}
 
void massiv::vuvod()
{
    for (int i=0;i<n;i++)
        cout<<"\t"<<S[i];
    cout<<endl;
}
 
int massiv::max ()
{
    int i;
    int N=0;
    for (i=0;i<n;i++)
        if (S[N]<S[i])
            N=i;
    return (N);
}
 
 
int massiv::min ()
{
    int i;
    int N=0;
    for (i=0;i<n;i++)
        if (S[N]>S[i])
            N=i;
    return (N);
}
 
void massiv::sort()
{
    int N,k,buf;
    for (int i=0;i<n-1;i++)
    {
        N=i;
        for (k=i+1;k<n;k++)
        if (S[k]>S[N]) N=k;
        buf=S[i];
        S[i]=S[N];
        S[N]=buf;
        
    }
}
 
void main()
{
    setlocale (LC_CTYPE,"rus");
    massiv S;
    S.vvod();
    cout<<"Максимальный элемент равен "<<S.S[S.max()]<<", его индекс: " <<S.max()<<endl;
    cout<<"Минимальный элемент равен "<<S.S[S.min()]<<", его индекс: "<<S.min()<<endl;
    cout<<"Отсортированный массив:"<<endl;
    S.sort();
    S.vuvod();
    system ("PAUSE");
}

// x.cpp: определяет точку входа для консольного приложения.
// это комментарий. Другим способом комментирования является /* комментарий */
 
// включение заголовочных файлов.
#include "stdafx.h" 
#include "stdafx.h" // включение одного и того же заголовочного файла во второй раз. Обычно так делать нельзя.
#include "iostream" // включение заголовочного файла. Кавычки вида " обычно обозначают, что файл является "пользовательским", то есть находится там же где проект. Обычно принято писать #include <iostream> так как это стандартный заголовочный файл, а для стандартных заголовочных файлов используются кавычки вида <>. В языке C++ не принято писать .h после имен заголовочных файлов, пишут .h в языке С.  
 
 
using namespace std; // программа использует пространство имен(namespace) std // Ключевое слово using в переводе с английского означает "используется". Классы cout и cin используемые дальше  объявлены в пространстве имен std и включены в программу посредством заголовочного файла  iostream
 
 
 // Класс, представляющий из себя массив чисел типа int. По другому подобные классы называются  последовательными контейнерами и реализованы в стандартной библиотеке как vector. 
 
class massiv {public: // объявление класса с названием massiv. все элементы класса являются public то есть доступными для всех
int n, *S; // переменные-члены класса. Тип int 4-байтовый (32битный). Указатель любого типа является 4 байтовым. Указатели очень важно инициализировать - я сам постоянно забываю инициализировать указатели. Переменная n - размер массива, S - сам массив. 
massiv (int =5); // конструктор класса. Конструктор это специальная функция, которая вызывается при создании экземпляра класса. Экземпляр класса создается в момент выделения памяти. 5 это значение, которым инициализируется параметр, по умолчанию
void vvod(); // функция ввода данных на консоль, не возвращающая значений
void vuvod();// функция вывода данных на консоль, не возвращающая значений
int max();// функция выясняющая индекс в массиве максимального элемента,  возвращающая значение типа int
int min();// функция выясняющая индекс в массиве минимального элемента,  возвращающая значение типа int
void sort();// функция сортировки массива, не возвращающая значений
};
 
massiv::massiv (int nn) // конструктор, это функция имя которой совпадает с именем класса. Аргумент - размер массива
{  // начало конструктора
n=nn; // присвоения значения количества элементов
S=new int [n];// выделение памяти. После подобного выделения нужно обязательно освобождать память оператором delete[] S. Если память не освобождена возникнет утечка памяти, и это очень серьезная проблема для крупных программ.
} // конец конструктора
 
void massiv::vvod() // ввод данных на консоль
{ // начало vvod()
 
// вывод строки на консоль
    cout << "Введите количество элементов массива: ";
 
// cout является стандартным классом вывода. << является переопределенным в классе cout оператором. Оператор это функция и можно переписать строчку примерно так    cout.operator<<("Введите количество элементов массива: "); // "Введите количество элементов массива: "  - это константный char массив. Инструкция должна завершаться точкой с запятой. Аккуратно - можно опечататься и заменить на : а компилятор выдаст ошибку.
 
 
 
// запрос количества элементов массива
    cin >> n;
 
// cin является стандартным классом ввода.  >> является переопределенным в классе оператором. По другому то же самое можно записать следующим образом cin.operator>>(n); где n это аргумент оператора
 
// Количество выделенной памяти под массив и n в данной программе не согласованы. То есть S=new int [n]; нужно вызвать здесь, предварительно освободив память выделенную в конструктора  операцией delete []S;
 
 
// запрос элементов массива
    for (int i = 0; i < n;i++) 
    {
        cout<<"\n S["<<i<<"]=";
        cin>>S[i];
    }
 
// цикл for это последовательность повторных исполнений инструкций внутри { }. Можно переписать без for по другому:
// cout<<"\n S["<<0<<"]="; cin>>S[0];
// cout<<"\n S["<<1<<"]="; cin>>S[1];
//...
// cout<<"\n S["<<n-1<<"]="; cin>>S[n-1];
// Для компактности подобной записи создан циклический оператор
 
// int i это объявление переменной-счетчика. Область видимости переменной только один цикл. Вне цикла использовать эту переменную нельзя. Но можно создать переменную с тем же именем. 
// i = 0 инициализация переменной, ей присваивается значение 0. = это операция присвоения значения.
// i < n  условие при котором выполняются заключенные в {} инструкции
// i++ постфиксная форма инкрементного увеличение переменной на единицу. Эквивалетно i = i + 1
// \n это escape-последовательность обозначающая переход каретки на новую строку. По другому пишется как endl
 
} // конец vvod()
 
void massiv::vuvod() // вывод данных на консоль
{ // начало vuvod()
    for (int i=0;i<n;i++)
        cout<<"\t"<<S[i]; // \t это escape-последовательность обозначающая табулирование
 
    cout<<endl; // перевести каретку на новую строку
} // конец vuvod()
 
int massiv::max () // выяснение индекса максимального элемента
{ // начало max
    int i; // объявление переменной счетчика цикла с именем i. Переменная не инициализирована. Перед использованием переменные должны быть проинициализированы.
    int N=0;  // объявление переменной индекса массива  с именем N. Переменная инициализирована 0
    for (i=0;i<n;i++) // цикличное изменение счетчика массива
        if (S[N]<S[i]) // сравнение двух элементов массива и сохранение индекса элемента в массиве
            N=i; // если S[N]<S[i] то  N=i;
    return (N); // возвращение значения
} // конец max
 
 
int massiv::min () // выяснение индекса  минимального элемента
{ // начало min
    int i; // счетчик
    int N=0; // индекс массива
    for (i=0;i<n;i++)// цикличное изменение счетчика массива
        if (S[N]>S[i]) // сравнение двух элементов
            N=i; // сохранение индекса элемента в массиве
    return (N); // возвращение значения из функции
} // конец min
 
void massiv::sort() // сортировка массива по убыванию ( пузырьковая)
{ // начало sort
    int N,k,buf; // N - индекс в массиве, i - счетчик, buf это переменная для того, чтобы обменять значения массива между собой
    for (int i=0;i<n-1;i++) // цикличное изменение счетчика массива
    {
        N=i; // присвоили индексу массива значение i
        for (k=i+1;k<n;k++) // цикличное изменение счетчика массива. 
 
//Чтобы отсортировать массив пузырьковым методом  нужно каждый элемент сравнить со всеми остальными  и переставить на i место kый элемент если выполняется условие  S[k]>S[i]
 
        if (S[k]>S[N]) N=k; // присвоили индексу массива значение k
 
// обмен значений двух элементов массива
        buf=S[i]; // сохранение  S[i] так как следующим оператором данные в этой переменной будут затерты
        S[i]=S[N]; // изменили S[i]
        S[N]=buf; // присвоили S[N] старое значение S[i]
        
    }
} // конец sort
 
void main() // функция main является точкой входа в программу. Функция не возвращает значений.
{ // начало main
    setlocale (LC_CTYPE,"rus"); // установка русской локали, LC_CTYPE численная константа ( объявленная в заголовочном файле), которая обозначает изменение способа обработки символов на консоли, "rus" это имя локали
    massiv S; // объявление переменной класса массив с вызовом конструктора и  выделением памяти под 5 элементов.
    S.vvod();  // вызов метода класса. Точка это операция доступа к членам класса.
    cout<<"Максимальный элемент равен "<<S.S[S.max()]<<", его индекс: " <<S.max()<<endl;
    cout<<"Минимальный элемент равен "<<S.S[S.min()]<<", его индекс: "<<S.min()<<endl;
    cout<<"Отсортированный массив:"<<endl;
    S.sort(); // сортировка массива
    S.vuvod(); // вывод массива
    system ("PAUSE"); // так делается, чтобы окно консоли не исчезло после выполнения. system исполняет команды shell. Shell в ОС Windows это cmd.exe
} // конец main

massiv::massiv (unsigned int n)
{
 s=new [n];// Здесь n - параметр, он перекрывает член с именем n
 if (S!=NULL) // или if (S!=null_ptr), если компилятор понимает null_ptr
 {
   this->n=n; // this->n - член данного экземпляра, имеющий имя n. Это полная форма его адресации и она не перекрывается. просто n - параметр
 }
 else
 {
   n=0;
 }
}

class massiv {public:
 int *S;
 unsigned int n;
 ...

unsigned int max();
unsigned int min();

unsigned int massiv::max()
{
 unsigned int i;
 unsigned int N=0;
 for (i=0; i<=n; --i)
 {
  if (S[N]<S[i])
  {
   N=i;
  }
 }
 return N;
}

unsigned int massiv::min()
{
 unsigned int i;
 unsigned int N=0;
 for (i=0; i<=n; --i)
 {
  if (S[N]>S[i])
  {
   N=i;
  }
 }
 return N;
}

nullptr

S=new int [n];

#include <iostream>
#include <new>
 
int main()
{
    double *ptr = new (std::nothrow_t()) double [1000000000];
    
    if (ptr == nullptr)
        std::cout << "OMG" << std::endl;
    
    return 0;
}

signed

massiv::massiv (unsigned int n)
{
 try
 {
  S=new int [n];
  this->n=n; // this->n - член данного экземпляра, имеющий имя n. Это полная форма его адресации и она не перекрывается. просто n - параметр
 }
 catch(bad_alloc)
 {
   S=nullptr;
   this->n=0; 
 }
}