Программирование на C++ для начинающих

В начале обучения мы говорили о пространствах имен (namespaces). Каждый класс в C++ использует свое пространство имен. Это сделано для того, чтобы избежать конфликтов при именовании переменных и функций. В файле students.cpp мы используем оператор принадлежности :: перед именем каждой функции. Это делается для того, чтобы указать компилятору, что эти функции принадлежат классу Students.

Создание объекта через указатель

При создании объекта, лучше не копировать память для него, а выделять ее в в куче с помощьюуказателя. И освобождать ее после того, как мы закончили работу с объектом. Реализуем это в нашей программе, немного изменив содержимое файла main.cpp.

/* main.cpp */

#include <iostream>

#include "students.h"

int main()

{

// Выделение памяти для объекта Students

Students *student = new Students;

std::string name;

std::string last_name;

// Ввод имени с клавиатуры

std::cout << "Name: ";

getline(std::cin, name);

// Ввод фамилии

std::cout << "Last name: ";

getline(std::cin, last_name);

// Сохранение имени и фамилии в объект класса Students

student->set_name(name);

student->set_last_name(last_name);

// Оценки

int scores[5];

// Сумма всех оценок

int sum = 0;

// Ввод промежуточных оценок

for (int i = 0; i < 5; ++i) {

std::cout << "Score " << i+1 << ": ";

std::cin >> scores[i];

// суммирование

sum += scores[i];

}

// Сохраняем промежуточные оценки в объект класса Student

student->set_scores(scores);

// Считаем средний балл

float average_ball = sum / 5.0;

// Сохраняем средний балл в объект класса Students

student->set_average_ball(average_ball);

// Выводим данные по студенту

std::cout << "Average ball for " << student->get_name() << " "

<< student->get_last_name() << " is "

<< student->get_average_ball() << std::endl;

// Удаление объекта student из памяти

delete student;

return 0;

}

При создании статического объекта, для доступа к его методам и свойствам, используют операция прямого обращения -- «.» (символ точки). Если же память для объекта выделяется посредством указателя, то для доступа к его методам и свойствам используется оператор косвенного обращения -- «->».

Конструктор и деструктор класса

Конструктор класса -- это специальная функция, которая автоматически вызывается сразу после создания объекта этого класса. Он не имеет типа возвращаемого значения и должен называться также, как класс, в котором он находится. По умолчанию, заполним двойками массив с промежуточными оценками студента.

class Students {

public:

// Конструктор класса Students

Students(int default_score)

{

for (int i = 0; i < 5; ++i) {

scores[i] = default_score;

}

}

private:

int scores[5];

};

int main()

{

// Передаем двойку в конструктор

Students *student = new Students(2);

return 0;

}

Мы можем исправить двойки, если ученик будет хорошо себя вести, и вовремя сдавать домашние задания. А на «нет» и суда нет :-)

Деструктор класса вызывается при уничтожении объекта. Имя деструктора аналогично имени конструктора, только в начале ставится знак тильды ~. Деструктор не имеет входных параметров.

#include <iostream>

class Students {

public:

// Деструктор

~Students()

{

std::cout << "Memory has been cleaned. Good bye." << std::endl;

}

};

int main()

{

Students *student = new Students;

// Уничтожение объекта

delete student;

return 0;

}

Следующий урок: Конструкторы и деструкторы классов в C++ >

В этом уроке мы более детально познакомимся с конструкторами и деструкторами класса, а также научимся работать с файлами в потоковом режиме, с помощью библиотеки fstream. Продолжим написание программы учета оценок.

Конструктор Students

Добавим в класс Students конструктор, который будет принимать имя и фамилию ученика, и сохранять эти значения в соответствующих переменных класса.

// Конструктор Students

Students::Students(std::string name, std::string last_name)

{

Students::set_name(name);

Students::set_last_name(last_name);

}

При создании нового объекта, мы должны передать конструктору имя и фамилию студента. Иначе компиляция программы завершится с ошибкой.

std::string name = "Василий";

std::string last_name = "Пупкин";

Students *student = new Students(name, last_name);

Теперь добавим прототип конструктора в файл students.h.

/* students.h */

#pragma once /* Защита от двойного подключения заголовочного файла */

#include <string>

class Students {

public:

// Конструктор класса Students

Students(std::string, std::string);

// Установка имени студента

void set_name(std::string);

// Получение имени студента

std::string get_name();

// Установка фамилии студента

void set_last_name(std::string);

// Получение фамилии студента

std::string get_last_name();

// Установка промежуточных оценок

void set_scores(int []);

// Установка среднего балла

void set_average_ball(float);

// Получение среднего балла

float get_average_ball();

private:

// Промежуточные оценки

int scores[5];

// Средний балл

float average_ball;

// Имя

std::string name;

// Фамилия

std::string last_name;

};

В файле students.cpp определим сам конструктор.

/* students.cpp */

#include <string>

#include <fstream>

#include "students.h"

// Конструктор Students

Students::Students(std::string name, std::string last_name)

{

Students::set_name(name);

Students::set_last_name(last_name);

}

// Установка имени студента

void Students::set_name(std::string student_name)

{

Students::name = student_name;

}

// Получение имени студента

std::string Students::get_name()

{

return Students::name;

}

// Установка фамилии студента

void Students::set_last_name(std::string student_last_name)

{

Students::last_name = student_last_name;

}

// Получение фамилии студента

std::string Students::get_last_name()

{

return Students::last_name;

}

// Установка промежуточных оценок

void Students::set_scores(int scores[])

{

int sum = 0;

for (int i = 0; i < 5; ++i) {

Students::scores[i] = scores[i];

sum += scores[i];

}

}

// Установка среднего балла

void Students::set_average_ball(float ball)

{

Students::average_ball = ball;

}

// Получение среднего балла

float Students::get_average_ball()

{

return Students::average_ball;

}

В main() мы принимаем от пользователя имя и фамилию ученика, и сохраняем их во временных локальных переменных. После этого создаем новый объект класса Students, передавая его конструктору эти переменные.

/* main.cpp */

#include <iostream>

#include "students.h"

int main(int argc, char *argv[])

{

// Локальная переменная, хранящая имя ученика

std::string name;

// И его фамилию

std::string last_name;

// Ввод имени

std::cout << "Name: ";

getline(std::cin, name);

// И фамилии

std::cout << "Last name: ";

getline(std::cin, last_name);

// Передача параметров конструктору

Students *student = new Students(name, last_name);

// Оценки

int scores[5];

// Сумма всех оценок

int sum = 0;

// Ввод промежуточных оценок

for (int i = 0; i < 5; ++i) {

std::cout << "Score " << i+1 << ": ";

std::cin >> scores[i];

// суммирование

sum += scores[i];

}

// Сохраняем промежуточные оценки в объект класса Student

student->set_scores(scores);

// Считаем средний балл

float average_ball = sum / 5.0;

// Сохраняем средний балл

student->set_average_ball(average_ball);

// Выводим данные по студенту

std::cout << "Average ball for " << student->get_name() << " "

<< student->get_last_name() << " is "

<< student->get_average_ball() << std::endl;

// Удаление объекта student из памяти

delete student;

return 0;

}

Сохранение оценок в файл

Чтобы после завершения работы с программой, все данные сохранялись, мы будем записывать их в текстовый файл.

Оценки каждого студента будут находится в отдельной строке. Имя и фамилии будут разделяться пробелами. После имени и фамилии ученика ставится еще один пробел, а затем перечисляются все его оценки.

Пример файла с оценками:

Василий Пупкин 5 4 5 3 3

Иван Сидоров 5 5 3 4 5

Андрей Иванов 5 3 3 3 3

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

#include <fstream>

// Запись данных о студенте в файл

void Students::save()

{

std::ofstream fout("students.txt", std::ios::app);

fout << Students::get_name() << " "

<< Students::get_last_name() << " ";

for (int i = 0; i < 5; ++i) {

fout << Students::scores[i] << " ";

}

fout << std::endl;

fout.close();

}

Переменная fout -- это объект класса ofstream, который находится внутри библиотеки fstream. Класс ofstream используется для записи каких-либо данных во внешний файл. Кстати, у него тоже есть конструктор. Он принимает в качестве параметров имя выходного файла и режим записи.

В данном случае, мы используем режим добавления -- std::ios:app (англ. append). После завершения работы с файлом, необходимо вызвать метод close() для того, чтобы закрыть файловый дескриптор.

Чтобы сохранить оценки студента, мы будем вызывать только что созданный метод save().

Students student = new Students("Василий", "Пупкин");

student->save();

Деструктор Students

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

// Деструктор Students

Students::~Students()

{

Students::save();

}

Добавим прототипы деструктора и метода save() в students.h.

/* students.h */

#pragma once /* Защита от двойного подключения заголовочного файла */

#include <string>

class Students {

public:

// Запись данных о студенте в файл

void save();

// Деструктор класса Students

~Students();

// Конструктор класса Students

Students(std::string, std::string);

// Установка имени студента

void set_name(std::string);

// Получение имени студента

std::string get_name();

// Установка фамилии студента

void set_last_name(std::string);

// Получение фамилии студента

std::string get_last_name();

// Установка промежуточных оценок

void set_scores(int []);

// Получение массива с промежуточными оценками

int *get_scores();

// Получение строки с промежуточными оценками

std::string get_scores_str(char);

// Установка среднего балла

void set_average_ball(float);

// Получение среднего балла

float get_average_ball();

private:

// Промежуточные оценки

int scores[5];

// Средний балл

float average_ball;

// Имя

std::string name;

// Фамилия

std::string last_name;

};

И определим эти функции в students.cpp.

/* students.cpp */

#include <string>

#include <fstream>

#include "students.h"

// Деструктор Students

Students::~Students()

{

Students::save();

}

// Запись данных о студенте в файл

void Students::save()

{

std::ofstream fout("students.txt", std::ios::app);

fout << Students::get_name() << " "

<< Students::get_last_name() << " ";

for (int i = 0; i < 5; ++i) {

fout << Students::scores[i] << " ";

}

fout << std::endl;

fout.close();

}

// Конструктор Students

Students::Students(std::string name, std::string last_name)

{

Students::set_name(name);

Students::set_last_name(last_name);

}

// Установка имени студента

void Students::set_name(std::string student_name)

{

Students::name = student_name;

}

// Получение имени студента

std::string Students::get_name()

{

return Students::name;

}

// Установка фамилии студента

void Students::set_last_name(std::string student_last_name)

{

Students::last_name = student_last_name;

}

// Получение фамилии студента

std::string Students::get_last_name()

{

return Students::last_name;

}

// Установка промежуточных оценок

void Students::set_scores(int scores[])

{

int sum = 0;

for (int i = 0; i < 5; ++i) {

Students::scores[i] = scores[i];

sum += scores[i];

}

}

// Получение массива с промежуточными оценками

int *Students::get_scores()

{

return Students::scores;

}

// Установка среднего балла

void Students::set_average_ball(float ball)

{

Students::average_ball = ball;

}

// Получение среднего балла

float Students::get_average_ball()

{

return Students::average_ball;

}

Содержимое main.cpp останется прежним. Скомпилируйте и запустите программу. Перед тем, как приложение завершит свою работу, в директории с исполняемым файлом будет создан новый текстовый файл с оценками -- students.txt.

Следующий урок: Векторы в C++ >.

Вектор в C++ -- это замена стандартному динамическому массиву, память для которого выделяется вручную, с помощью оператора new.

Разработчики языка рекомендуют в использовать именно vector вместо ручного выделения памяти для массива. Это позволяет избежать утечек памяти и облегчает работу программисту.

Пример создания вектора

#include <iostream>

#include <vector>

int main()

{

// Вектор из 10 элементов типа int

std::vector<int> v1(10);

// Вектор из элементов типа float

// С неопределенным размером

std::vector<float> v2;

// Вектор, состоящий из 10 элементов типа int

// По умолчанию все элементы заполняются нулями

std::vector<int> v3(10, 0);

return 0;

}

Управление элементами вектора

Создадим вектор, в котором будет содержаться произвольное количество фамилий студентов.

#include <iostream>

#include <vector>

#include <string>

int main()

{

// Поддержка кириллицы в консоли Windows

setlocale(LC_ALL, "");

// Создание вектора из строк

std::vector<std::string> students;

// Буфер для ввода фамилии студента

std::string buffer = "";

std::cout << "Вводите фамилии студентов. "

<< "По окончание ввода введите пустую строку" << std::endl;

do {

std::getline(std::cin, buffer);

if (buffer.size() > 0) {

// Добавление элемента в конец вектора

students.push_back(buffer);

}

} while (buffer != "");

// Сохраняем количество элементов вектора

unsigned int vector_size = students.size();

// Вывод заполненного вектора на экран

std::cout << "Ваш вектор." << std::endl;

for (int i = 0; i < vector_size; i++) {

std::cout << students[i] << std::endl;

}

return 0;

}

Методы класса vector

Для добавления нового элемента в конец вектора используется метод push_back(). Количество элементов определяется методом size(). Для доступа к элементам вектора можно использовать квадратные скобки [], также, как и для обычных массивов.

* pop_back() -- удалить последний элемент

* clear() -- удалить элемент вектора

* empty() -- проверить вектор на пустоту

Подробное описание всех методов std::vector (на английском) есть на C++ Reference.

Наследование позволяет избежать дублирования лишнего кода при написании классов. Пусть в базе данных ВУЗа должна храниться информация о всех студентах и преподавателях. Представлять все данные в одном классе не получится, поскольку для преподавателей нам понадобится хранить данные, которые для студента не применимы, и наоборот.

* Создание базового класса

* Наследование от базового класса

o Конструктор базового класса

o Создание объекта класса student

* Создание класса-наследника teacher

o Создание объекта класса teacher

* Когда нужно использовать конструктор

Создание базового класса

Для решения этой задачи создадим базовый класс human, который будет описывать модель человека. В нем будут храниться имя, фамилия и отчество.

Создайте файл human.h:

// human.h

#ifndef HUMAN_H_INCLUDED

#define HUMAN_H_INCLUDED

#include <string>

#include <sstream>

class human {

public:

// Конструктор класса human

human(std::string last_name, std::string name, std::string second_name)

{

this->last_name = last_name;

this->name = name;

this->second_name = second_name;

}

// Получение ФИО человека

std::string get_full_name()

{

std::ostringstream full_name;

full_name << this->last_name << " "

<< this->name << " "

<< this->second_name;

return full_name.str();

}

private:

std::string name; // имя

std::string last_name; // фамилия

std::string second_name; // отчество

};

#endif // HUMAN_H_INCLUDED

Наследование от базового класса

Теперь создайте новый класс student, который будет наследником класса human. Поместите его в файл student.h.

// student.h

#ifndef STUDENT_H_INCLUDED

#define STUDENT_H_INCLUDED

#include "human.h"

#include <string>

#include <vector>

class student : public human {

public:

// Конструктор класса Student

student(

std::string last_name,

std::string name,

std::string second_name,

std::vector<int> scores

) : human(

last_name,

name,

second_name

) {

this->scores = scores;

}

// Получение среднего балла студента

float get_average_score()

{

// Общее количество оценок

unsigned int count_scores = this->scores.size();

// Сумма всех оценок студента

unsigned int sum_scores = 0;

// Средний балл

float average_score;

for (unsigned int i = 0; i < count_scores; ++i) {

sum_scores += this->scores[i];

}

average_score = (float) sum_scores / (float) count_scores;

return average_score;

}

private:

// Оценки студента

std::vector<int> scores;

};

#endif // STUDENT_H_INCLUDED

Функция get_average_score вычисляет среднее арифметическое всех оценок студента. Всепубличные свойства и методы класса human будут доступны в классе student.

Конструктор базового класса

Для того, чтобы инициализировать конструктор родительского класса (в нашем случае -- это сохранение имени, фамилии и отчества ученика), используется следующий синтаксис:

// Конструктор класса Student

student(

// аргументы конструктора текущего класса

) : human(

// инициализация конструктора родительского класса

) {

// инициализация конструктора текущего класса

}

В конструктор класса human мы передаем инициалы человека, которые сохраняются в экземпляре класса. Для класса students, нам необходимо задать еще и список оценок студента. Поэтому конструктор students принимает все аргументы конструктора базового класса, а также дополнительные аргументы для расширения функционала:

// Конструктор класса Student

student(

std::string last_name,

std::string name,

std::string second_name,

std::vector<int> scores

) : human(

last_name,

name,

second_name

) {

this->scores = scores;

}

Список оценок студента хранится в векторе.

Создание объекта класса student

Реализуем пользовательский интерфейс для работы с классом student.

// main.cpp

#include <iostream>

#include <vector>

#include "human.h"

#include "student.h"

int main(int argc, char* argv[])

{

// Оценки студента

std::vector<int> scores;

// Добавление оценок студента в вектор

scores.push_back(5);

scores.push_back(3);

scores.push_back(2);

scores.push_back(2);

scores.push_back(5);

scores.push_back(3);

scores.push_back(3);

scores.push_back(3);

scores.push_back(3);

// Создание объекта класса student

student *stud = new student("Петров", "Иван", "Алексеевич", scores);

// Вывод полного имени студента (используется унаследованный метод класса human)

std::cout << stud->get_full_name() << std::endl;

// Вывод среднего балла студента

std::cout << "Средний балл: " << stud->get_average_score() << std::endl;

return 0;

}

В этом примере мы написали программу, которая создает объект класса student, сохраняя в нем его имя, фамилию, отчество и список оценок.

После инициализации объекта, происходит вывод полного имени студента с помощью функцииget_full_name. Эта функция была унаследована от базового класса human.

Затем программа вычислияет средний балл студента и выводит его на экран. Этим занимается функция get_average_score, которую мы описали внутри класса student.

Мы реализовали часть функционала для нашей базы данных института (я конечно утрирую, когда оперирую столь серьезными высказываниями про настоящую базу данных :)

Создание класса-наследника teacher

Нужно создать еще один класс, в котором будут храниться данные преподавателей. Дадим ему название -- teacher. Как вы уже поняли, мы не будем описывать все методы этого класса с нуля, а просто унаследуем его от класса human. Тогда, не нужно будет реализовывать хранение имени, фамилии и отчества препода. Это уже есть в базовом классе human.

Создайте файл teacher.h:

// teacher.h

#ifndef TEACHER_H_INCLUDED

#define TEACHER_H_INCLUDED

#include "human.h"

#include <string>

class teacher : public human {

// Конструктор класса teacher

public:

teacher(

std::string last_name,

std::string name,

std::string second_name,

// Количество учебных часов за семетр у преподавателя

unsigned int work_time

) : human(

last_name,

name,

second_name

) {

this->work_time = work_time;

}

// Получение количества учебных часов

unsigned int get_work_time()

{

return this->work_time;

}

private:

// Учебные часы

unsigned int work_time;

};

#endif // TEACHER_H_INCLUDED

У класса teacher появилось новое свойство -- количество учебных часов, отведенное преподавателю на единицу времени (семестр). Весь остальной функционал наследуется от базового класса human. Если бы мы писали все с нуля, то одинакового кода бы получилось в разы больше, и его поддержка усложнилась бы на порядок.

Создание объекта класса teacher

Изменим содержимое файла main.cpp, чтобы проверить работу класса teacher.

#include <iostream>

#include "human.h"

#include "teacher.h"

int main(int argc, char* argv[])

{

// Количество учебных часов преподавателя

unsigned int teacher_work_time = 40;

teacher *tch = new teacher("Васильков", "Петр", "Сергеевич", teacher_work_time);

std::cout << tch->get_full_name() << std::endl;

std::cout << "Количество часов: " << tch->get_work_time() << std::endl;

return 0;

}

Если сборка программы прошла без ошибок, то результат работы программы будет таким:

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

Также, мы можем создать класс, который будет описывыть студента заочной формы обучения. Его мы унаследовали бы от класса student, добавив какие-либо дополнительные данные.

В класс human можно добавить еще больше свойств, которые будут описывать данные, имеющиеся у любого человека. Например, номер паспорта, дату рождения, прописку и место проживания.

Подобный подход позволяет в разы уменьшить дублирование кода в реальных проектах, и упросить его поддержку.

Когда нужно использовать конструктор

Если у класса много свойств -- их совсем не обязательно задавать в конструкторе. Для сохранения отдельных свойств класса используют set-функции. Например, для сохранения номера паспорта, можно создать публичный метод set_passport_number(std::string number), который будет принимать значение свойства и сохранять его в объекте, через переменную this.



Яндекс.Директ

В прошлой статье Функции в Функции в С++ для начинающих. Рекурсия (3) Фибоначи была использована логическая операция, о которой я не писал раньше. Значит надо рассмотреть что такое логические операции и какие логические операции бывают в C++

Логические операции используют для получения сложных условий путем комбинирования простых. В C++ логические операции делятся на 3 вида

И = &&

ИЛИ = ||

НЕ = !

Логические операции ИЛИ и НЕ я уже затрагивал в прошлых статьях, но не описывал что это такое и как логическими операциями в C++ пользоваться.

Покажу простой пример использования логических операций в коде C++. Пользователю предлагается ввести какие-то данные и проверяется условие правильности ввода. Пишем код C++

В качестве примера будем вводить число с клавиатуры и проверять введенное число на правильность

PHP

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32 #include <conio.h>

#include <iostream.h>

#include <stdlib.h>

void main()

{

system("cls"); //Очистка экрана С++

int n1,n2; //будем вводить числа

cout<<"Wwedi 1 dwa raza"<<endl; //Предлагаем пользователю ввести данные

cin>>n1>>n2; //Запоминаем введенные данные в памяти

//Проверяем введенные данные с соответствием нужного условия И

if (n1==1 && n2==1) cout<<"Werno"<<endl; //Если первое число = 1 и Второе число = 1, выводим на экран Верно

else cout<<"Wi wweli ne to cto was prosili"; //Если же какое-то из чисел не равно единице - отображаем Ввод неверный

//Проверяем введенные данные с соответствием нужного условия Или

cout<<endl<<"Wwedi 1 ili 5"<<endl; //Предлагаем пользователю ввести 1 или 5

cin>>n1; //Запоминаем вводимое число в память

if (n1==1||n1==5) cout<<"Werno"<<endl; //Если введенное число равно 1 или 5 выводим на экран Верно

else cout<<"Wi wweli ne to cto was prosili"; //Если же какое-то из чисел не равно единице - отображаем Ввод неверный

//Проверяем введенные данные с соответствием нужного условия НЕ

cout<<endl<<"Wwedi luboe chislo krome 7"<<endl; //Предлагаем пользователю ввести любое число кроме 7

cin>>n1; //Запоминаем вводимое число в память

if (n1 != 7) cout<<"Werno"<<endl; //Если введенное число не равно 7 выводим на экран Верно

else cout<<"Wi wweli ne to cto was prosili"; //Если же какое-то из чисел не равно единице - отображаем Ввод неверный

getch(); //Ожидаем нажатие клавиши

return; //Выходим из функции

}

Так как комментарии для некоторых начинающих непонятны, опишу что мы тут делаем. В первом случае мы вводим 2 числа с клавиатуры. Наше условие, что оба этих числа должны быть равны единице. Для этого используем логическую операцию И

Во втором случае мы вводим только одно число и проверяем его на совпадение с другим значением. Этих значений может быть 2, 3, 4 и сколько угодно. Для проверки такого совпадения используем логическую операцию ИЛИ

В третьем случае используется логическая операция НЕ. Мы вводим число с клавиатуры и проверяем его на условие, что оно Не равно 7

Это достаточно простой материал для изучения C++,самое главное понимать как происходит ввод информации и вывод информации на экран потому что во всем коде основная часть это ввод и вывод информации. А сами логические функции ограничиваются коротким выражением if (Логическая функция) и могут запутать начинающих изучение C++

То что написано выше, это я читал в какой-то книге, где не помню. Иногда в исходниках можно встретить использование некоторых других логических операций. Как пример исключающее или (XOR)

PHP

1

2

3

4

5

6

7

8

9

10

11

12

13

14 #include <stdlib.h>

#include <iostream.h>

void main()

{

system("CLS");

int x=5;

int y=10;

x^=y; //x или не у (использование исключающего или)

cout<<x<<" "<<y;

cin.get();

}

Один из примеров использования такого исключающего или - обмен двух переменных местами без использования дополнительной переменной

PHP

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15 #include <stdlib.h>

#include <iostream.h>

void main()

{

system("CLS");

int x=5;

int y=10;

x^=y; //x или не у (использование исключающего или)

y^=x; //y или не x

x^=y; //x или не y

cout<<x<<" "<<y;

cin.get();

}

#include <iostream>

using namespace std;

int w[500][500];//массив весов

bool used[500];//массив использованных вершин

int d[500];//массив длин пути

int inf=1000000000;//условная бесконечность

int main()

{

int n,m,v1,v2,x=0,y=0,z=0;

cin>>n>>m>>v1>>v2;

v1--;v2--;

memset(w,0,sizeof(w));

memset(d,1000000000,sizeof(d));

memset(used,false,sizeof(used));

for (int i=0;i<n;i++) d[i]=inf;

for (int i=0;i<m;i++)

{cin>>x>>y>>z;w[x-1][y-1]=z;w[y-1][x-1]=z;}

d[v1]=0;

while (true){

int from,zfrom=inf;

for (int i=0;i<n;i++)

if ((zfrom>d[i]) && !(used[i])) {from=i;zfrom=d[i];}

if (zfrom>=inf) break;

used[from]=true;

for(int to=0;to<n;to++)

if (w[from][to]!=0)

if ((!used[to]) && (d[to]>d[from]+w[from][to])) d[to]=d[from]+w[from][to];

}

if (d[v2]<inf) cout<<d[v2];else cout<<"-1";

return 0;

}

C++. Урок 11. Файловый ввод-вывод.

Опубликовано 13.12.2012 автором admin

Всем доброго дня!

До этого мы уже затрагивали тему ввода-вывода. И это было простой консолью. Теперь мы поговорим офайловом вводе-выводе.

Что из себя представляет эта тема понятно уже по названию, но все же captain mod on:

Файловый ввод-вывод позволяет считывать данные из множества различных файлов, и выводить их в другие (или те же) файлы captain mod off.

Итак, для считывания файлов можно использовать функцию freopen, которая позволяет перенаправлять потоки ввода-вывода. Ввод всегда идет в поток stdin, вывод же в stdout. Теперь о том, как пользоватьсяfreopen-ом:

1 freopen ("имя файла", "мод", "имя потока");

Имя файла:

С этим все должно быть понятно, сюда мы пишем имя файла, в который будет направлен поток.

Мод:

Есть 6 модов:

1) Считывание, или «r», от слова read. Используется для потока ввода. Для считывания файл должен существовать.

2) Запись, или «w», от английского write. Используется для потока вывода. Если файла не существует, то он будет создан, иначе -- перезаписан.

3) Добавление, или «a», от слова append. Используется для вывода, отличается от «w» тем, что продолжает записывать в файл, а не очищает его.

4,5,6) Те же моды, с разницей в том, что их можно использовать и для ввода, и для вывода. Вот сами моды «r+», «w+», «a+».

Поток:

1) Стандартный поток ввода -- stdin;

2) Стандартный поток вывода -- stdout;

3) Стандартный поток ошибок, этакий error_log -- stderr;

Программа считывающая из input.txt и записывающая в output.txt:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34 # include <iostream>

# include <cstdlib>

# include <cstdio>

// две новые библиотеки, нужны для работы freopen

using namespace std;

int d[1000000], n;

/*

переменные, инициализированные до функции main,

считаются глобальными т.е. изначально равны нулю и

могут быть вызваны в любой части программы.

Рекомендую создавать массивы глобальными всегда.

*/

int sum (int l, int r)

{

int ans = 0;

n = r - l + 1;

for (int i = l, j = 1; i <= r; ++i, ++j)

d[j] = i;

for (int i = 1; i <= n; ++i)

ans += d[i];

return ans;

}

int main()

{

freopen ("input.txt", "r", stdin);

freopen ("output.txt", "w", stdout);

int a, b;

cin >> a >> b;

cout << sum (a, b) << "\n";

for (int i = 1; i <= n; ++i)

cout << d[i] << " ";

return 0;

}

Так же для считывания можно использовать функции ifstream и ofstream, которые находятся в библиотекеfstream.

ifstream считывает с заданного файла.

ofstream выводит в заданный файл.

Теперь о том как их написать:

2 ifstream название_функции_ввода ("название_файла_ввода");

ofstream название_функции_вывода ("название_файла_вывода");

Пример той же программы с использованием функций библиотеки fstream:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29 # include <fstream>

using namespace std;

int d[1000000], n;

int sum (int l, int r)

{

int ans = 0;

n = r - l + 1;

for (int i = l, j = 1; i <= r; ++i, ++j)

d[j] = i;

for (int i = 1; i <= n; ++i)

ans += d[i];

return ans;

}

int main()

{

ifstream read_file ("input.txt");

ofstream write_file ("output.txt");

/*

для считывания с файла input.txt мы будем

использовать функцию read_file,

можете заменить ее на что-нибудь другое

*/

int a, b;

read_file >> a >> b;

write_file << sum (a, b) << "\n";

for (int i = 1; i <= n; ++i)

write_file << d[i] << " ";

return 0;

}

Стоит отметить, что ifstream использует мод «a», а ofstream мод «w». Можно открыть сколько угодно файлов, главное дать уникальное имя для функций ввода.

Для закрытия считывания или записи используйте функцию .close():

1 имя_функции_ввода/вывода.close();

Ну, вроде все. Спасибо за прочтение!

ПРИЛОЖЕНИЕ

#include "stdafx.h"

#include "Sort.h"

#include "SortDoc.h"

#include "SortView.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

//объявление глобальных переменных

int mas[20]={30,5,17,8,1,14,12,3,77,2,45,89,33,21,6}, mas2[20], kol=15, count=0;

CString str;

bool sort=false;

int metod=0;

//1- quicksort

//2- shell

//3- пузырька

/////////////////////////////////////////////////////////////////////////////

// CSortView

IMPLEMENT_DYNCREATE(CSortView, CView)

BEGIN_MESSAGE_MAP(CSortView, CView)

//{{AFX_MSG_MAP(CSortView)

ON_COMMAND(ID_QUICK, OnQuick)

ON_COMMAND(ID_PUZIROK, OnPuzirok)

ON_COMMAND(ID_SHELL, OnShell)

//}}AFX_MSG_MAP

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////

// CSortView construction/destruction

CSortView::CSortView()

{

// TODO: add construction code here

}

CSortView::~CSortView()

{

}

BOOL CSortView::PreCreateWindow(CREATESTRUCT& cs)

{

// TODO: Modify the Window class or styles here by modifying

// the CREATESTRUCT cs

return CView::PreCreateWindow(cs);

}

/////////////////////////////////////////////////////////////////////////////

// CSortView drawing

//функция вывода данных на экран

void CSortView::OnDraw(CDC* pDC)

{

CSortDoc* pDoc = GetDocument();

ASSERT_VALID(pDoc);

// TODO: add draw code for native data here

int i;

//выводим исходный массив на экран

for(i=0;i<kol;i++)

{

str.Format("%d,",mas[i]);//формирование строки

pDC->TextOut(10+i*20,10,str);//вывод на экран

}

//если был выбран какой-нибудь метод сортировки

if(sort)

{

if(metod==1)//если выбран Quicksort

pDC->TextOut(10,40,"Обменная сортировка с разделением (quicksort)");//вывод строки на экран

if(metod==2)//если выбран Shell

pDC->TextOut(10,40,"Метод Шелла");//вывод строки на экран

if(metod==3)//если выбран Bubble

pDC->TextOut(10,40,"Метод прямого обмена (Пузырька)");//вывод строки на экран

//выводим отсортированный массив

for(i=0;i<kol;i++)

{

str.Format("%d,",mas2[i]);//формирование строки

pDC->TextOut(10+i*20,80,str);//вывод строки на экран

}

str.Format("Количество перестановок в нашем случае: %d",count);//формирование строки

pDC->TextOut(10,110,str);//вывод строки на экран

if(metod==3)//если был выбран метод "Пузырька"

{

str.Format("Максимальное количество перестановок для массива из %d элементов методом 'Пузырька': %d",kol, kol*(kol-1)/2);//формирование строки

pDC->TextOut(10,140,str);//вывод строки на экран

}

}

}

/////////////////////////////////////////////////////////////////////////////

// CSortView diagnostics

#ifdef _DEBUG

void CSortView::AssertValid() const

{

CView::AssertValid();

}

void CSortView::Dump(CDumpContext& dc) const

{

CView::Dump(dc);

}

CSortDoc* CSortView::GetDocument() // non-debug version is inline

{

ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSortDoc)));

return (CSortDoc*)m_pDocument;

}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////

// CSortView message handlers

//при выборе сортировки Quicksort

void CSortView::OnQuick()

{

//объявление локальных переменных

sort=true;

metod=1;

int i;

count=0;

for(i=0;i<kol;i++)

{

mas2[i]=mas[i];

}

quicksort(0, kol-1);//вызов функции quicksort

Invalidate(true);//перерисовка содержимого окна

}

//при выборе сортировки Shell

void CSortView::OnShell()

{

//объявление локальных переменных

sort=true;

metod=2;

int ii,t=5,i,j, k, s, m, h[6], x;

count=0;

for(ii=0;ii<kol;ii++)

{

mas2[ii]=mas[ii];

}

h[1]=9; h[2]=5; h[3]=3; h[4]=2; h[5]=1;

////////////////////////////////////////////

//АЛГОРИТМ

for(m=1;m<=t;m++)

{

k=h[m];

s=-k;

for(i=k+1; i<=kol;i++)

{

x=mas2[i];

j=i-k;

while (x<mas2[j] && j<kol)

{

mas2[j+k]=mas2[j];

j=j-k;

}

mas2[j+k]=x;

count++;

}

}

x=mas2[0];

mas2[0]=mas2[1];

mas2[1]=x;

////////////////////////////////////////////

Invalidate(true);//перерисовка содержимого окна

}

//при выборе сортировки Bubble

void CSortView::OnPuzirok()

{

//объявление локальных переменных

int dop;

bool end;

count=0;

sort=true;

metod=3;

int i, j;

for(i=0;i<kol;i++)

{

mas2[i]=mas[i];

}

////////////////////////////////////////////

//АЛГОРИТМ

for(i=0;i<kol;i++)

{

end=true;

for(j=i+1;j<kol;j++)

{

if(mas2[i]>mas2[j])

{

dop=mas2[i];

mas2[i]=mas2[j];

mas2[j]=dop;

end=false;

count++;

}

}

if(end==true) break;

}

/////////////////////////////////////////////

Invalidate(true);//перерисовка содержимого окна

}

//функция быстрого поиска

void CSortView::quicksort(int l, int r)

{

int i, j;

i=l;j=r;

{

part(l, r, i, j);

if(i<r)quicksort(i, r);// переход к сортировке левой части

if(j>l)quicksort(l, j);// переход к сортировке правой части

}

}

//функция поиска по частям

void CSortView::part(int l, int r, int &i, int &j)

{

int x, dop;

i=l;

j=r;

x=(l+r)/2;

do

{

while(mas2[i]<mas2[x])

i++;

while(mas2[j]>mas2[x])

j--;

if(i<=j)

{

dop=mas2[i];

mas2[i]=mas2[j];

mas2[j]=dop;

i++;j--;count++;

}

}

while(i<j);

}



Шифр цезаря

#include <iostream> //Подключаем библиотеку, обрабатывающую

//стандартные потоки ввода/вывода

#include <conio> //Библиотека содержащит функцию getch

const int ABCSize = 26; //Размер алфавита

const char low_ch[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',

'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}; //Массив

//строчных букв, которые шифруются также строчными

const char high_ch[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'}; //Массив

//заглавных букв, которые шифруются также заглавными

std::string cipher(const std::string &input_s, const int shift)

{ //Функция осуществляет сдвиг строки по алфавиту на указанную величину

bool Ok; //Был ли символ определен как буква алфавита и затем зашифрован

std::string output_s(""); //Зашифрованная строка, вначале инициализируется

//пустой строкой

for(unsigned i = 0; i < input_s.length(); i++)

{ //Для всех символов шифруемой строки

Ok = false; //Вначале сбрасываем значение флага

for(int j = 0; j < ABCSize; j++)

{ //Перебираем все буквы алфавита на поиск соответствия

if (input_s[i] == low_ch[j]) //Если символ оказался строчной буквой алфавита

{

j += shift; //Сдвигаем букву по алфавиту на указанное значение

while (j >= ABCSize) j -= ABCSize; //Если значение вышло за диапазон,

while (j < 0) j += ABCSize; //корректируем его

output_s += low_ch[j]; //Добавляем полученный символ в конец

//зашифрованной строки

Ok = true; //Символ был благополучно зашифрован и добавлен в строку

break; //Перебор для данного символа можно закончить

}

else if (input_s[i] == high_ch[j]) //То же самое, если символ оказался

//заглавной буквой алфавита

{

j += shift;

if (j >= ABCSize) j -= ABCSize;

else if (j < 0) j += ABCSize;

output_s += high_ch[j];

Ok = true;

break;

}

}

if (!Ok) output_s += input_s[i]; //Если символ не является буквой алфавита,

//записываем его без изменений

}

return output_s; //По окончании возвращаем получившуюся строку

}

int main()

{

std::string s; //Шифруемая/дешифруемая строка

std::cout << "If you want to cipher string, press \"1\", if you want to decode,"

" press \"2\"";

bool Ok = false; //Корректна ли нажатая клавиша

int shift = //Величина сдвига

while(!Ok) //Пока не будет нажато "1" или "2"

{

switch(getch())

{

case '1': //Если нажато "1", шифруем строку

{

std::cout << "\nInput shift: ";

std::cin >> shift;

std::cout << "Input string to cipher: ";

while (std::cin >> s) //Шифруем одним и тем же сдвигом по одному слову

{

std::cout << cipher(s, shift) << ' ';

if (std::cin.get() == '\n') break; //Заканчиваем по нажатию Enter

}

Ok = true; //Клавиша была нажата корректно

} break;

case '2': //Если нажато "2", пытаемся дешифровать строку

{

bool Done = false; //Завершен ли процесс дешифровки

std::cout << "\nInput string to decode: ";

getline(std::cin, s); //Считываем всю дешифруемую строку

for (int i = 0; i < ABCSize && !Done; i++) //Пробуем разные величины сдвига

//до тех пор, пока не расшифруем или не проверим все возможные его значения

{

std::cout << "\nWith shift equal " << i << " we have such string:\n";

std::cout << cipher(s, i);

std::cout << "\nIf decoding is done, press \"1\"";

if (getch() == '1') Done = true; //Строка дешифрована

}

Ok = true; //Клавиша была нажата корректно

} break;

default: std::cout << "Press either \"1\" or \"2\"!"; //Некорректно нажатая

//клавиша

}

}

getch();

}

Размещено на Allbest.ru

...