Форум программистов, компьютерный форум CyberForum.ru

Что требуется ? - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Перевод из сантиметры в метры http://www.cyberforum.ru/cpp-beginners/thread936962.html
Задача такая: нужно перевести из сантиметра в метры, и результат записать в виде "n метров, n сантиметров". Не могу скомпилировать, пишет ошибку LNK2019 и LNK1120. Вот сам код: #include <iostream> using std::cout; using std::cin; int sm_to_m(int); int sm, m, smmod; const int M = 100; // постоянная, количество см в м
C++ getline, string, запись в файл, русский язык #include <iostream> using std::ios; using std::cin; using std::cout; using std::endl; #include <string> using std::string; #include <fstream> http://www.cyberforum.ru/cpp-beginners/thread936942.html
Найти количество заштрихованых квадратов C++
Помогите решить задачку пожалуйста. Программа должна вывести количество заштрихованых квадратов (5) если квадраты прилегают друг к другу это щитается как 1.
C++ Нулевые значения массива
Для чего инициализировать массив нулевыми значениями?
C++ Каковая точность округления? http://www.cyberforum.ru/cpp-beginners/thread936895.html
Какова точность округления у таких функций, как round/ceil/floor? Сколько раз я могу просуммировать число с погрешностью (имеется ввиду, что у меня уже есть число x=0.000000..1 и до каких пор выражение y += x будет удовлетворять условию round(y) == 0f)?
C++ Кто за сколько времени выучил с++ на среднем уровне ? Здравствуйте !Возник вопрос (если можно так назвать) .Просто интересно .Кто за сколько времени, выучил с++ на среднем уровне ? подробнее

Показать сообщение отдельно
lemegeton
 Аватар для lemegeton
2909 / 1338 / 133
Регистрация: 29.11.2010
Сообщений: 2,720
13.08.2013, 12:20     Что требуется ?
2 на велосипедах:
C++
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <ctime>
#include <cstdlib>
#include <iostream>
#include <iomanip>
 
class Box {
 public:
  enum Material {
    WOOD, CARTON, PLASTIC
  };
  Box() {}
  Box(double a, double b, double c, Material material)
    : a(a), b(b), c(c), material(material) {}
  const double &getA() const { return a; }
  const double &getB() const { return b; }
  const double &getC() const { return c; }
  const Material &getMaterial() const { return material; }
 private:
  double a, b, c;
  Material material;
};
 
std::ostream &operator<<(std::ostream &stream, const Box::Material &material) {
  switch (material) {
    case Box::Material::WOOD:
      stream << "wood";
      break;
    case Box::Material::CARTON:
      stream << "carton";
      break;
    case Box::Material::PLASTIC:
      stream << "plastic";
      break;
    default:
      stream << "unknown";
  };
  return stream;
}
 
std::ostream &operator<<(std::ostream &stream, const Box &box) {
  return stream << std::fixed << std::setprecision(3) <<
    "Box{a=" << box.getA() << ", b=" << box.getB() <<
    ", c=" << box.getC() << ", material='" << box.getMaterial() <<
    "'}";
}
 
Box::Material getRandomMaterial() {
  int randomNumber = rand() % 3;
  switch (randomNumber) {
    case 0: return Box::Material::WOOD;
    case 1: return Box::Material::CARTON;
    case 2: return Box::Material::PLASTIC;
  }
  return Box::Material::WOOD;
}
 
Box getRandomBox() {
  return Box((rand() % 10000) / 1000., (rand() % 10000) / 1000.,
    (rand() % 10000) / 1000., getRandomMaterial());
}
 
struct BoxMaterialComparator {
  BoxMaterialComparator(const Box::Material &material) : material(material) {}
  bool operator()(const Box &box) {
    return box.getMaterial() == material;
  }
  Box::Material material;
};
 
template <class Predicate>
Box *partition(Box *first, Box *last, Predicate predicate) {
  while (first != last) {
    while (predicate(*first)) {
      ++first;
      if (first == last) return first;
    }
    do {
      --last;
      if (first == last) return first;
    } while (!predicate(*last));
    std::swap(*first, *last);
    ++first;
  }
  return first;  
}
 
template <class Generator>
void generate(Box *first, Box *last, Generator generator) {
  while (first != last) {
    *first++ = generator();
  }
}
 
template <class Predicate>
void sort(Box *first, Box *last, Predicate predicate) {
  for (Box *i = first; i != last - 1; ++i) {
    for (Box *j = i + 1; j != last; ++j) {
      if (predicate(*i, *j)) {
        std::swap(*i, *j);
      }
    }
  }
}
 
const double &max(const double &a, const double &b) {
  return (a > b) ? a : b;
}
 
double getLongestEdgeValue(const Box &box) {
  return max(max(box.getA(), box.getB()), box.getC());
}
 
bool compareByLongestSide(const Box &a, const Box &b) {
  return getLongestEdgeValue(a) < getLongestEdgeValue(b);
}
 
int main(int, char**) {
  srand(time(0));
  
  const int NUMBER_OF_BOXES = 7 + rand() % 5;
  Box boxes[NUMBER_OF_BOXES];
  
  generate(boxes, boxes + NUMBER_OF_BOXES, getRandomBox);
  
  std::cout << "Boxes:" << std::endl;
  for (int i = 0; i < NUMBER_OF_BOXES; ++i) {
    std::cout << boxes[i] << std::endl;
  }
 
  Box::Material selectedMaterial = getRandomMaterial();
  std::cout << "Selected material: " << selectedMaterial << "." <<
    std::endl << std::endl;
 
  Box *lastBox = partition(boxes, boxes + NUMBER_OF_BOXES,
    BoxMaterialComparator(selectedMaterial));
  
  std::cout << "Not sorted:" << std::endl;
  for (Box *i = boxes; i != lastBox; ++i) {
    std::cout << *i << std::endl;
  }
  std::cout << std::endl;
 
  sort(boxes, lastBox, compareByLongestSide);
  
  std::cout << "Sorted:" << std::endl;
  for (Box *i = boxes; i != lastBox; ++i) {
    std::cout << *i << std::endl;
  }
  std::cout << std::endl;
  
  return 0;
}
Добавлено через 14 часов 12 минут
С первой могу помочь вычислениями.
Готовый прямоугольник, вывод его на экран, определение правильности, вычисление площади.
Вам остается сделать только выборку и сортировку. С уже готовыми функциями и классами.
C++
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#include <cmath>
#include <iostream>
#include <iomanip>
#include <stdexcept>
 
const double EPSILON = 0.00001;
const double PI = 3.141592653589793;
 
 
class Point {
 public:
  Point() : x(0), y(0) {}
  Point(const double &x, const double &y) : x(x), y(y) {}
  const double &getX() const { return x; }
  const double &getY() const { return y; }
 private:
  double x;
  double y;
};
 
std::ostream &operator<<(std::ostream &stream, const Point &point) {
  return stream << std::fixed << std::setprecision(3) <<
    "Point{x=" << point.getX() << ", y=" << point.getY() << "}";
}
 
class Polygon {
 public:
  const static int MAXIMUM_NUMBER_OF_POINTS = 50;
  Polygon() : numberOfPoints(0) {}
  const Point &getPoint(int index) const {
    if (index >= numberOfPoints) {
      throw std::out_of_range("Requested point does not exist."); 
    }
    return points[index];
  }
  void addPoint(const Point &point) {
    if (numberOfPoints >= MAXIMUM_NUMBER_OF_POINTS) {
      throw std::out_of_range("Maximum number of points reached.");
    }
    points[numberOfPoints++] = point;
  }
  int getNumberOfPoints() const { return numberOfPoints; }
 private:
  Point points[MAXIMUM_NUMBER_OF_POINTS];
  int numberOfPoints;
};
 
std::ostream &operator<<(std::ostream &stream, const Polygon &polygon) {
  stream << "Polygon{numberOfPoints=" << polygon.getNumberOfPoints() << 
    "," << std::endl;
  for (int i = 0; i < polygon.getNumberOfPoints(); ++i) {
    stream << "    " << polygon.getPoint(i) << std::endl;
  }
  return stream << "}";
}
 
bool equals(const double &a, const double &b, const double &epsilon = EPSILON) {
  return fabs(a - b) <= EPSILON;
}
 
double getDistance(const Point &a, const Point &b) {
  return sqrt(pow(a.getX() - b.getX(), 2.) + pow(a.getY() - b.getY(), 2.));
}
 
/**
 * Определение равносторонности многоугольника.
 * Многоугольник считается равносторонним, если все его стороны равны.
 *
 * @param polygon многоугольник
 * @param epsilon задаваемая точность сравнения чисел с плавающей точкой
 * @result истина, если многоугольник равносторонний и ложь, если у
 *         многоугольника меньше двух точек или он неравносторонний
 */
bool isEquilateral(const Polygon &polygon, const double &epsilon = EPSILON) {
  int numberOfPoints = polygon.getNumberOfPoints();
  if (numberOfPoints < 3) {
    return false;
  }
  double firstDistance = getDistance(polygon.getPoint(0), polygon.getPoint(1));
  for (int i = 1; i < numberOfPoints; ++i) {
    double thisDistance = getDistance(polygon.getPoint(i),
      polygon.getPoint((i + 1) % numberOfPoints));
    if (!equals(firstDistance, thisDistance, epsilon)) {
      return false;
    }
  }
  return true;
}
 
/**
 * Определение правильности многоугольника.
 * Многоугольник считается правильным, если он равносторонний и
 * для любой его стороны вычисляемый радиус описанной окружности
 * одинаков.
 *
 * @param polygon многоугольник
 * @param epsilon задаваемая точность сравнения чисел с плавающей точкой
 * @result истина, если многоугольник правильный и ложь, если у
 *         многоугольника меньше трех сторон или он неправильный
 */
bool isRegular(const Polygon &polygon, const double &epsilon = EPSILON) {
  int numberOfPoints = polygon.getNumberOfPoints();
  if (!isEquilateral(polygon, epsilon) || numberOfPoints < 3) {
    return false;
  }
  double firstSide = getDistance(polygon.getPoint(0), polygon.getPoint(1));
  double circumcircleRadius = firstSide / (2 * sin(PI / (2 * numberOfPoints)));
  
  for (int i = 1; i < numberOfPoints; ++i) {
    double thisSide = getDistance(polygon.getPoint(i),
      polygon.getPoint((i + 1) % numberOfPoints));
    double thisCircumcircleRadius = thisSide / 
      (2 * sin(PI / (2 * numberOfPoints)));
    if (!equals(thisCircumcircleRadius, circumcircleRadius, epsilon)) {
      return false;
    }
  }  
  return true;
}
 
/**
 * Поиск площади правильного многоугольника по формуле.
 *
 * @param polygon многоугольник, площадь которого надо найти
 * @result площадь правильного многоугольника
 */
double getAreaOfRegular(const Polygon &polygon) {
  int numberOfPoints = polygon.getNumberOfPoints();
  if (numberOfPoints < 3) {
    return 0;
  }
  double side = getDistance(polygon.getPoint(0), polygon.getPoint(1));
  return (numberOfPoints * pow(side, 2.0)) /
    (4 * tan(PI / numberOfPoints));
}
 
int main(int, char**) {
  // создание многоугольника
  Polygon p; 
  // добавление точек (квадрат)
  p.addPoint(Point(0, 0)); 
  p.addPoint(Point(0, 2));
  p.addPoint(Point(2, 2));
  p.addPoint(Point(2, 0));
 
  // вывод на экран
  std::cout << p << std::endl;
  
  // проверка на правильность
  if (isRegular(p)) {
    // подсчет площади правильного(!) многоугольника
    double area = getAreaOfRegular(p);
    std::cout << "Regular polygon with area of " << area << std::endl;
  } else {
    std::cout << "Not a regular polygon." << std::endl;
  }
}
 
Текущее время: 18:35. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru