Обращение к private параметрам класса в main

/*
Что такое класс в С/С++?//Возможно-неверно... да и, скорее всего-неверно...
Класс-некая структура, состоящая из параметров(переменных) и методов(функций).
К примеру, вот нужно создать некий комплекс параметров(имя, рост, вес, пол, группа крови, и т.д.).
Однако, что бы не писать несколько структур, можно создать пару классов. Один класс-должен быть исходным.
Вот, если нам нужно будет сделать класс Человек и Собака, значит... Эти оба класса наследуют исходные параметры, плюс мы добавляем новые параметры к классу Собака(длина хвоста, цвет шерсти, и т.д.). А к классу Человек добавляем(цвет волос, цвет кожи и т.д.).
Так же, классы могут содержать методы(функции). Методы предназначены для каких то определённых операций, будь то с классовыми переменными, будь то с переменными из вне класса...
Методы так же, могут наследоваться, как и переменные, и доступ как к переменным, так и к функциям нужно прописывать отдельно.
 
Какие есть типы доступов параметров и методов в классах?
В классах есть следующие параметры доступа:
public - публичные параметры. Они могут быть вызваны из вне класса(из любого места...)
Нужен данный тип доступа для того, что бы можно было обращаться ко всем параметрам в любом месте...
static - статические параметры. Они могут быть вызваны только в классах(в исходном, и наследующем)
Такой тип доступа нужен для того, что бы параметр был доступен только лишь внутри класса.
Статические переменные объявляются могут так же, как и публичные переменные, которые наследуются другими классами, но их использовать можно только внутри класса(т.е. написать тупо CClass1.StaticX не получится...)
Статические параметры с публичным доступом(например) можно использовать только в классах и в функциях класса, но не как в других функциях, или даже в главном коде программы... Если в краце - как то так...
private - приватные параметры. Они могут быть вызваны только внутри исходного класса, и заносить данные в них можно только лишь  внутри функций класса... Короче говоря - это только родной класс, и ничего более...
Нужен данный тип доступа для того, что бы ограничить некоторые параметры от прямого изменения из вне.
Например - оценки... Что бы, когда будем создавать некую библиотеку классов, другой программист не смог просто так взять, и заменить значение параметра оценки... Для ограничения к доступу, так сказать...
 
Как идёт обращение к параметрам/функциям в public?
Параметры public можно использовать в абсолюте, где угодно. Это открытые параметры, которые могут быть вызваны из любой функции,   из любого цикла... в любой момент времени.
Делается это следующим образом:
имя_класса   переменная_класса.название_публичной_переменной
Например:
class CClass{ public: int x; }
CClass ExampleCClass;
ExampleCClass.x=10;//Таким образом, мы занесли в публичный параметр класса CClass значение 10
 
Как идёт обращение к параметрам/функциям в private?
Приватные параметры могут быть вызваны только внутри функций в классе, и только там, и нигде более.
Т.е. написав в main функции наращивание некой приватной переменной не получится, т.к. идёт вызов параметра вне класса.
Аналогично и с классами. В классе A2, который наследует параметры A1(у которого есть private параметр) не может использовать приватные параметры А1 Т.е. класс А2, не может иметь приватные параметры А1(так же, как и функции, которые используют такие параметры).
Обращаться лучше всего по средствам публичных функций, либо статических функций.
Например:
class CCLass{ private: int Result; /// /// public: void EnterResult(){std::cin>>Result;} }
//Теперь, как же внести значение в Result?
CClass ExampleClass;
ExampleClass.EnterResult();//Вызов функции ввода в Result
Не получится сделать:
class CCLass{ private: int Result; /// /// public: void EnterResult(){std::cin>>Result;} }
class ClError:CCLass{}
ClError ErrorClass;
ErrorClass.EnterResult();// - здесь компилятор выдаст ошибку о том, что функцию использовать нельзя, т.к. параметр,    требуемый для её работы, можно вызвать только внутри исходного класса
 
Как идёт обращение к параметрам в static?
Тип доступа static определяет лишь то, что данная переменная, либо функция должна использоватся только внутри самого класса, либо внутри класса-наследодателя. Т.е. что это значит?
Это значит, что теперь нельзя будет просто так взять, и объявить CClass1.StaticX=10. Теперь, нужно указывать, что StaticX-член класса.
Например:
сlass CClass{public: static int StaticX;}//Данный класс содержит одну публичную переменную, доступ к которой возможен только лишь при условии указания класса
class CClass2:CClass{public: void EnterStaticX(){std::cin>>CClass2::StaticX;} };//К примеру, у нас есть второй класс, который наследует параметры первого класса   
//И у данного класса есть лишь один публичный метод(публичная функция) - ввод в статический параметр StaticX. 
//Т.к. второй класс полностью наследовал все параметры из первого класса, то доступ к данной переменной осуществляется 
именно таким образом(если через функцию, хотя, по другому то, и нельзя...)  Можно конечно объявить значение статического 
параметра во вне кода(т.е. это примерно так: int Cclass2::StaticX=10; Здесь мы присвоили публично-статическому параметру значение 10)...
Не получится сделать:
сlass CClass{public: static int StaticX;};//Объявление нашего класса
int main()//Главная функция программы(главный код, если грубо сказать...)
{
CClass ErrorClass;//Переменная нашего класса)
ErrorClass::StaticX=10;//Здесь компилятор выдаст ошибку, суть которой заключается в том, что параметр StaticX
//используется во вне класса(он используется в главном коде, а это, сторонняя функция,
//значит-вне класса...
return 0;
}
*/
 
#include "stdafx.h"//Подключение библиотеки с стандартными пред-установками(подключением) модулей. 
//Добавляется в Microsoft Visual Studio 2012
#include <iostream>//Подключение библиотеки input-output stream
#include <Windows.h>//Подключение библиотеки системных команд Windows
 
 
 
//using namespace std;
 
 
 
//Мой класс 1(основной класс)
class MyClass1
{//Начало класса
int a1;//Данный параметр можно использовать только внутри класса MyClass1
public://Параметры, с доступом public будут доступны везде, и обращаться к ним можно из любого места
//Т.е. это полный доступ всех параметров, указанных в public
int b1;//Данный параметр будет доступен как исходному классу, так и наследуемому классу
private://Параметры, с доступом private можно использовать только лишь внутри самого класса
//Для примера, нужно запретить другим классам влиять на данную переменную, или даже, запретить конечному пользователю использовать эти параметры.
//Для этих целей(и не только) используются параметры в private
int c1;//Данный параметр будет возможно использовать только лишь внутри данного класса, и не использовать, как публичные переменные
//Т.е. например, нужно ограничить какую то переменную от пользователя.
public://Данные функции будут так же, доступны и в наследуемом классе(т.е. в классе, который будет наследовать параметры MyClass1)
void Enterc1()//Данная функция вводит в приватную переменную c1 данные из консольного ввода(standart::console_input)
{//Начало функции
std::cin>>b1;//Ввод данных в приватную переменную b1
}//Конец функции
void Seec1()//Данная функция отображает содержимое переменной c1
{//Начало функции
std::cout<<b1;
}//Конец функции
};//Конец класса
 
 
 
//Мой класс 2(дополнительный класс, который наследует параметры класса MyClass1)
class MyClass2:MyClass1
{//Начало класса
public://Объявление публичных параметров
int z1;//Публичная целочисленная переменная
};//Конец класса
 
 
 
 
//Объявление переменных наших классов
MyClass1 Test1;// Переменная MyClass1
MyClass2 Test2;// Переменная MyClass2
 
 
 
 
//Класс для примера использования статических переменных(параметров с статическим доступом)
class StaticExample
{//Начало класса
public:
static int StaticX;//Статическая переменная в классе StaticExample
//Т.е. данная переменная является статической, и не может быть использована простым методов, однако, её можно спокойно вызвать и из класса
//Т.е. например, нужно вывести значение этой переменной на экран. Значит, пишется далее следующий код:
//std::cout<<StaticExample::StaticX; - отображение значения StaticX(static) на экране
};//Конец класса
 
int StaticExample::StaticX=100;//Таким образом, можно занести данные в статические переменные
 
 
 
//Данный класс наследует статические параметры из класса StaticExample
class MyClass3:StaticExample
{//Начало класса
public://Объявление публичных параметров
void EnterStaticX()//Публичная функция ввода данных в статически-публичный параметр
{//Начало функции
//std::cin>>StaticX; - так делать нельзя, т.к. static, ровно так же, как и private может использована лишь внутри своего класса
std::cin>>MyClass3::StaticX;//Вот так, можно использовать статические переменные внутри даже наследуемого класса
}//Конец функции
void SeeStaticX()
{//Начало функции
std::cout<<MyClass3::StaticX;//Идёт вывод значения статически-публичного параметра на экран
}//Конец функции
};//Конец класса
 
MyClass3 Test3;//Переменная нашего 3-го класса, который наследует статические параметры у отдельного класса
 
 
//Главная функция(главный код программы)
int _tmain(int argc, _TCHAR* argv[])
{//Начало программы
setlocale(LC_ALL,"Russian");
std::cout<<"Введите значение переменной (private)c1 из класса MyClass1"<<std::endl;
Test1.Enterc1();//Вызов функции ввода данных в приватную переменную b1 класса MyClass1
system("cls");//Запуск системной команды очистки экрана консоли
 
std::cout<<"Значение переменной (private)c1 равно:"<<std::endl;
Test1.Seec1();//Вызов функции отображения содержимого приватной переменной b1 из класса MyClass1
std::cout<<std::endl;//Отображение перехода на след. строку(или просто, переход на след. строку)
system("pause");//Системная команда паузы
//Test2.Enterc1(); - в классе MyClass2 вызвать ввод в приватную для MyClass1 переменную не получится, т.к. не смотря на то, 
//что функция ввода в с1-публичная, используемая переменная с1-приватная. Значит-функция не доступна для сторонних классов
system("cls");//Запуск системной команды очистки экрана консоли
 
std::cout<<"Значение переменной (private)b1 класса MyClass1 (определена в коде)=";
Test1.b1=100;//Попытка присвоить публичную переменную b1 как 100(т.е. b1 равна 100)
std::cout<<Test1.b1<<std::endl;//Вывод на экран содержимого переменной b1
system("pause");//Системная команда паузы
system("cls");//Запуск системной команды очистки экрана консоли
std::cout<<"Введите значение переменной(static int StaticX) класса MyClass3: = ";
Test3.EnterStaticX();//Запуск функции из класса MyClass3 для ввода данных в статическую переменную StaticX
system("cls");//Запуск системной команды очистки экрана консоли
std::cout<<"Значение переменной (static int StaticX) из класса MyClass3 = ";
Test3.SeeStaticX();//Запуск функции из MyClass3 для отображения статической переменной(значения переменной) на экране
std::cout<<std::endl;//Отображение перехода на след. строку(или просто, переход на след. строку)
system("pause");//Системная команда паузы
system("cls");//Запуск системной команды очистки экрана консоли
//Test3.StaticX; - так тоже, обращаться к статическому параметру нельзя...
//std::cout<<Test3::StaticX; - и так нельзя обращаться к статическому параметру... Почему? Потому что параметр вызывается во 
//вне класса. Функция main не принадлежит ни одному из классов, которые имеют доступ к данной переменной. 
//А это значит-статическая переменная используется во вне класса...
 
return 0;//Возвращение 0(ноль), как результата работы функции
//Как и любая функция - главная функция должна возвращать результат...
}//Конец программы