Форум программистов, компьютерный форум, киберфорум
C для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C (Си) > C для начинающих
Войти
Регистрация
Восстановить пароль
Карта форума Темы раздела Блоги Сообщество Поиск Заказать работу  
 
Рейтинг 4.63/8: Рейтинг темы: голосов - 8, средняя оценка - 4.63
14 / 7 / 2
Регистрация: 25.03.2014
Сообщений: 90
1

Перевести код из C++ в чистый Си

25.05.2017, 15:52. Показов 1569. Ответов 4
Метки нет (Все метки)
Author24 — интернет-сервис помощи студентам
Из-за наличия специфики плюсов (векторы, классы, operator) вообще не удаётся интерпретировать логику, заложенную в код. Помогите, пожалуйста, разобраться и получить хотя бы шаблонный вариант на Си, который я смогу дописать до рабочего.

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

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
158
159
160
161
162
163
164

// TBezierInterpolation.cpp
#include <vector>
#include <iostream>
#include <cmath>
 
using namespace std;
 
#define EPSILON 1.0e-5
#define RESOLUTION 32
 
class Point2D
{
public:
    double x, y;
    
    Point2D() { x = y = 0.0; };
    Point2D(double _x, double _y) { x = _x; y = _y; };
    
    Point2D operator +(const Point2D &point) const { return Point2D(x + point.x, y + point.y); };
    Point2D operator -(const Point2D &point) const { return Point2D(x - point.x, y - point.y); };
    Point2D operator *(double v) const { return Point2D(x * v, y * v); };
    void operator +=(const Point2D &point) { x += point.x; y += point.y; };
    void operator -=(const Point2D &point) { x -= point.x; y -= point.y; };
    
    void normalize()
    {
        double l = sqrt(x * x + y * y);
        x /= l;
        y /= l;
    }
};
 
class Segment
{
public:
    Point2D points[4];
    
    void calc(double t, Point2D &p)
    {
        double t2 = t * t;
        double t3 = t2 * t;
        double nt = 1.0 - t;
        double nt2 = nt * nt;
        double nt3 = nt2 * nt;
        p.x = nt3 * points[0].x + 3.0 * t * nt2 * points[1].x + 3.0 * t2 * nt * points[2].x + t3 * points[3].x;
        p.y = nt3 * points[0].y + 3.0 * t * nt2 * points[1].y + 3.0 * t2 * nt * points[2].y + t3 * points[3].y;
    };
};
 
bool calculateSpline(const vector<Point2D> &values, vector<Segment> &bezier)
{
    int n = values.size() - 1;
    
    if (n < 2)
        return false;
    
    bezier.resize(n);
    
    Point2D tgL;
    Point2D tgR;
    Point2D cur;
    Point2D next = values[1] - values[0];
    next.normalize();
    
    double l1, l2, tmp, x;
    
    --n;
    
    for (int i = 0; i < n; ++i)
    {
        bezier[i].points[0] = bezier[i].points[1] = values[i];
        bezier[i].points[2] = bezier[i].points[3] = values[i + 1];
        
        cur = next;
        next = values[i + 2] - values[i + 1];
        next.normalize();
        
        tgL = tgR;
        
        tgR = cur + next;
        tgR.normalize();
        
        if (abs(values[i + 1].y - values[i].y) < EPSILON)
        {
            l1 = l2 = 0.0;
        }
        else
        {
            tmp = values[i + 1].x - values[i].x;
            l1 = abs(tgL.x) > EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
            l2 = abs(tgR.x) > EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
        }
        
        if (abs(tgL.x) > EPSILON && abs(tgR.x) > EPSILON)
        {
            tmp = tgL.y / tgL.x - tgR.y / tgR.x;
            if (abs(tmp) > EPSILON)
            {
                x = (values[i + 1].y - tgR.y / tgR.x * values[i + 1].x - values[i].y + tgL.y / tgL.x * values[i].x) / tmp;
                if (x > values[i].x && x < values[i + 1].x)
                {
                    if (tgL.y > 0.0)
                    {
                        if (l1 > l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    }
                    else
                    {
                        if (l1 < l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    }
                }
            }
        }
        
        bezier[i].points[1] += tgL * l1;
        bezier[i].points[2] -= tgR * l2;
    }
    
    l1 = abs(tgL.x) > EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
    
    bezier[n].points[0] = bezier[n].points[1] = values[n];
    bezier[n].points[2] = bezier[n].points[3] = values[n + 1];
    bezier[n].points[1] += tgR * l1;
    
    return true;
}
 
int main()
{
    vector<Point2D> testValues;
    vector<Segment> spline;
    Point2D p;
 
    testValues.push_back(Point2D(0, 0));
    testValues.push_back(Point2D(20, 0));
    testValues.push_back(Point2D(45, -47));
    testValues.push_back(Point2D(53, 335));
    testValues.push_back(Point2D(57, 26));
    testValues.push_back(Point2D(62, 387));
    testValues.push_back(Point2D(74, 104));
    testValues.push_back(Point2D(89, 0));
    testValues.push_back(Point2D(95, 100));
    testValues.push_back(Point2D(100, 0));
 
    calculateSpline(testValues, spline);
 
    for (auto s : spline)
    {
        for (int i = 0; i < RESOLUTION; ++i)
        {
            s.calc((double)i / (double)RESOLUTION, p);
            cout << p.x << " " << p.y << endl;
        }
    }
 
    cout << testValues.back().x << " " << testValues.back().y << endl;
 
    return 0;
}
Bash
1

g++ -std=c++11 TBezierInterpolation.cpp
0
Лучшие ответы (1)
Сообщение: #10488942
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
 25.05.2017, 15:52
Ответы с готовыми решениями:

Ребята,можно ли этот код перевести на чистый си(Код смешан с си++)
Задача: 4 балла: Разработать игровое поле для змейки. Продумать способ хранения змейки,...

Перевести с C++ на чистый Си
#include &quot;stdafx.h&quot; #include &lt;iostream&gt; #include &lt;locale&gt; using namespace std; void...

Перевести с С++ на чистый С
Дан текстовый файл. Создать символьный файл, содержащий все символы, встретившиеся в тексте,...

Чистый js код
inf.delegate.store.push({selector:'.cn', callback: function(e, elem){ ms =...

4
14 / 7 / 2
Регистрация: 25.03.2014
Сообщений: 90
28.05.2017, 22:29  [ТС] 2
Хотя бы подскажите, пожалуйста, как перевести в Си следующие строки:
C++
1

Point2D operator +(const Point2D &point) const { return Point2D(x + point.x, y + point.y); };
C++
1
2
3

class Point2D
{
public:
C++
1

Point2D() { x = y = 0.0; }
C++
1

bool calculateSpline(const vector<Point2D> &values, vector<Segment> &bezier)
C++
1
2

vector<Point2D> testValues;
vector<Segment> spline;
0
278 / 186 / 75
Регистрация: 12.04.2017
Сообщений: 1,088
Записей в блоге: 2
29.05.2017, 08:29 3
Лучший ответ Сообщение было отмечено Loinch как решение

Решение

Вывод немного, но отличается. Не нашел в чем проблема.

С99
https://ideone.com/zX14t5
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

// TBezierInterpolation.c
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>
#include <float.h>
 
#define RESOLUTION 32
#define  POINTS_LEN 10
 
typedef struct
{
    double x, y;
}Point2D;
 
 
Point2D Point2DAdd( Point2D *left,  Point2D *right)
{
    Point2D newPoint = {left->x + right->x, left->y + right->y};
    return newPoint;
}
Point2D Point2DSubtract( Point2D *left,  Point2D *right)
{
    Point2D newPoint = {left->x - right->x, left->y - right->y};
    return newPoint;
}
Point2D Point2DMultiply( Point2D *left, double v)
{
    Point2D newPoint = {left->x * v, left->y * v};
    return newPoint;
}
 
 
void Point2DNormalize(Point2D *point)
{
    double l = sqrt(point->x * point->x + point->y * point->y);
    point->x /= l;
    point->y /= l;
}
 
 
typedef struct
{
    Point2D points[4];
}Segment;
 
void SegmentCalc(Segment *seg,double t, Point2D *p)
{
    double t2 = t * t;
    double t3 = t2 * t;
    double nt = 1.0 - t;
    double nt2 = nt * nt;
    double nt3 = nt2 * nt;
    p->x = nt3 * seg->points[0].x + 3.0 * t * nt2 * seg->points[1].x + 3.0 * t2 * nt * seg->points[2].x + t3 * seg->points[3].x;
    p->y = nt3 * seg->points[0].y + 3.0 * t * nt2 * seg->points[1].y + 3.0 * t2 * nt * seg->points[2].y + t3 * seg->points[3].y;
}
 
 
bool CalculateSpline( Point2D values[], int valuesSize, Segment bezier[])
{
    int n = valuesSize - 1;
 
    if (valuesSize < 2)
        return false;
 
    Point2D tgL= {0.0,0.0};
    Point2D tgR= {0.0,0.0};
    Point2D cur= {0.0,0.0};
    Point2D next = Point2DSubtract(&values[1] ,&values[0]);
    Point2D tmpPoint= {0.0,0.0};
    Point2DNormalize(&next);
 
    double l1 = 0.0, l2= 0.0, tmp= 0.0, x= 0.0;
 
    --n;
 
    for (int i = 0; i < n; ++i)
    {
        bezier[i].points[0] = bezier[i].points[1] = values[i];
        bezier[i].points[2] = bezier[i].points[3] = values[i + 1];
 
        cur = next;
        next = Point2DSubtract(&values[i + 2],&values[i + 1]);
        Point2DNormalize(&next);
 
        tgL = tgR;
 
        tgR = Point2DAdd(&cur,&next);
        Point2DNormalize(&tgR);
 
        if (abs(values[i + 1].y - values[i].y) < DBL_EPSILON)
        {
            l1 = l2 = 0.0;
        }
        else
        {
            tmp = values[i + 1].x - values[i].x;
            l1 = abs(tgL.x) > DBL_EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
            l2 = abs(tgR.x) > DBL_EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
        }
 
        if (abs(tgL.x) > DBL_EPSILON && abs(tgR.x) > DBL_EPSILON)
        {
            tmp = tgL.y / tgL.x - tgR.y / tgR.x;
            if (abs(tmp) > DBL_EPSILON)
            {
                x = (values[i + 1].y - tgR.y / tgR.x * values[i + 1].x - values[i].y + tgL.y / tgL.x * values[i].x) / tmp;
                if (x > values[i].x && x < values[i + 1].x)
                {
                    if (tgL.y > 0.0)
                    {
                        if (l1 > l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    }
                    else
                    {
                        if (l1 < l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    }
                }
            }
        }
        tmpPoint = Point2DMultiply(&tgL , l1);
        bezier[i].points[1] = Point2DAdd(& bezier[i].points[1],&tmpPoint);
        tmpPoint = Point2DMultiply(&tgR , l2);
        bezier[i].points[2] = Point2DSubtract(& bezier[i].points[2],&tmpPoint);
    }
 
    l1 = abs(tgL.x) > DBL_EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
 
    bezier[n].points[0] = bezier[n].points[1] = values[n];
    bezier[n].points[2] = bezier[n].points[3] = values[n + 1];
    tmpPoint = Point2DMultiply(&tgR , l1);
    bezier[n].points[1] = Point2DAdd(& bezier[n].points[1],&tmpPoint);
 
    return true;
}
 
int main()
{
 
    Point2D testValues[POINTS_LEN] = {{0.0, 0.0},
                               {20.0, 0.0},
                               {45.0, -47.0},
                               {53.0, 335.0},
                               {57.0, 26.0},
                               {62.0, 387.0},
                               { 74.0, 104.0},
                              { 89.0, 0.0},
                             {95.0, 100.0},
                             { 100.0, 0.0} };
    Segment spline[100];
 
    Point2D p = {0.0,0.0};
 
 
    CalculateSpline(testValues,POINTS_LEN, spline);
 
    for(int i = 0; i < POINTS_LEN - 1;i++)
    {
        for (int j = 0; j < RESOLUTION; j++)
        {
            SegmentCalc(&spline[i],(double)j / (double)RESOLUTION, &p);
            printf("%lf %lf\n", p.x, p.y);
        }
    }
 
    printf("%lf %lf\n", testValues[POINTS_LEN - 1].x,testValues[POINTS_LEN - 1].y);
 
    return 0;
}
1
14 / 7 / 2
Регистрация: 25.03.2014
Сообщений: 90
29.05.2017, 11:00  [ТС] 4
Огромнейшее спасибо RuningMan за перевод!

Благодаря указанию дополнительных уровней предупреждений компилятора удалось оперативно найти и устранить баг. Он крылся в использовании функции abs вместо fabs. Похоже, плюсовой компилятор видя, что функция получает аргументы с плавающей точкой выбирал её правильную реализацию. gcc -std=c11 при компиляции выбрал именно то, что написано в коде - функцию, которая работает с целыми числами. Хотя и поругался по-своему:
Bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

$ gcc -pipe -std=c11 -g -ggdb -ggdb3 -O0 -DDEBUG -finline-functions -Wall  -Wextra -Wpedantic -Wshadow -Wconversion -Wsign-conversion -Winit-self -Wunreachable-code -Wformat-y2k -Wformat-nonliteral -Wformat-security -Wmissing-include-dirs -Wswitch-default -Wtrigraphs -Wstrict-overflow=5 -Wfloat-equal -Wundef -Wshadow -Wbad-function-cast -Wcast-qual -Wcast-align -Wwrite-strings -Winline -Wsuggest-attribute=const -Wsuggest-attribute=pure -Wsuggest-attribute=noreturn -Wsuggest-attribute=format -Wmissing-format-attribute -Wlogical-op -o TBezierInterpolation TBezierInterpolation.c -lm
TBezierInterpolation.c: In function ‘CalculateSpline’:
TBezierInterpolation.c:86:27: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
   if (abs(values[i + 1].y - values[i].y) < DBL_EPSILON) {
                           ^
TBezierInterpolation.c:90:16: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
    l1 = abs(tgL.x) > DBL_EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
                ^
TBezierInterpolation.c:91:16: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
    l2 = abs(tgR.x) > DBL_EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
                ^
TBezierInterpolation.c:94:14: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
   if (abs(tgL.x) > DBL_EPSILON && abs(tgR.x) > DBL_EPSILON) {
              ^
TBezierInterpolation.c:94:42: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
   if (abs(tgL.x) > DBL_EPSILON && abs(tgR.x) > DBL_EPSILON) {
                                          ^
TBezierInterpolation.c:96:4: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
    if (abs(tmp) > DBL_EPSILON) {
    ^
TBezierInterpolation.c:119:14: warning: conversion to ‘int’ from ‘double’ may alter its value [-Wconversion]
  l1 = abs(tgL.x) > DBL_EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
              ^
Вот окончательный вариант программы. Ещё раз спасибо RuningMan за перевод!

https://ideone.com/JE5fRB

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
158
159
160
161
162
163
164
165
166

// TBezierInterpolation.c
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <stdbool.h>
#include <float.h>
 
#define RESOLUTION 32
#define  POINTS_LEN 10
 
typedef struct {
    double x, y;
} Point2D;
 
 
Point2D Point2DAdd( Point2D *left,  Point2D *right)
{
    Point2D newPoint = {left->x + right->x, left->y + right->y};
    return newPoint;
}
 
Point2D Point2DSubtract( Point2D *left,  Point2D *right)
{
    Point2D newPoint = {left->x - right->x, left->y - right->y};
    return newPoint;
}
 
Point2D Point2DMultiply( Point2D *left, double v)
{
    Point2D newPoint = {left->x * v, left->y * v};
    return newPoint;
}
 
void Point2DNormalize(Point2D *point)
{
    double l = sqrt(point->x * point->x + point->y * point->y);
    point->x /= l;
    point->y /= l;
}
 
typedef struct {
    Point2D points[4];
} Segment;
 
void SegmentCalc(Segment *seg,double t, Point2D *p)
{
    double t2 = t * t;
    double t3 = t2 * t;
    double nt = 1.0 - t;
    double nt2 = nt * nt;
    double nt3 = nt2 * nt;
    p->x = nt3 * seg->points[0].x + 3.0 * t * nt2 * seg->points[1].x + 3.0 * t2 * nt * seg->points[2].x + t3 * seg->points[3].x;
    p->y = nt3 * seg->points[0].y + 3.0 * t * nt2 * seg->points[1].y + 3.0 * t2 * nt * seg->points[2].y + t3 * seg->points[3].y;
}
 
 
bool CalculateSpline( Point2D values[], int valuesSize, Segment bezier[])
{
    int n = valuesSize - 1;
 
    if (valuesSize < 2) {
        return false;
    }
 
    Point2D tgL= {0.0,0.0};
    Point2D tgR= {0.0,0.0};
    Point2D cur= {0.0,0.0};
    Point2D next = Point2DSubtract(&values[1] ,&values[0]);
    Point2D tmpPoint= {0.0,0.0};
    Point2DNormalize(&next);
 
    double l1 = 0.0, l2= 0.0, tmp= 0.0, x= 0.0;
 
    --n;
 
    for (int i = 0; i < n; ++i) {
        bezier[i].points[0] = bezier[i].points[1] = values[i];
        bezier[i].points[2] = bezier[i].points[3] = values[i + 1];
 
        cur = next;
        next = Point2DSubtract(&values[i + 2],&values[i + 1]);
        Point2DNormalize(&next);
 
        tgL = tgR;
 
        tgR = Point2DAdd(&cur,&next);
        Point2DNormalize(&tgR);
 
        if (fabs(values[i + 1].y - values[i].y) < DBL_EPSILON) {
            l1 = l2 = 0.0;
        } else {
            tmp = values[i + 1].x - values[i].x;
            l1 = fabs(tgL.x) > DBL_EPSILON ? tmp / (2.0 * tgL.x) : 1.0;
            l2 = fabs(tgR.x) > DBL_EPSILON ? tmp / (2.0 * tgR.x) : 1.0;
        }
 
        if (fabs(tgL.x) > DBL_EPSILON && fabs(tgR.x) > DBL_EPSILON) {
            tmp = tgL.y / tgL.x - tgR.y / tgR.x;
            if (fabs(tmp) > DBL_EPSILON) {
                x = (values[i + 1].y - tgR.y / tgR.x * values[i + 1].x - values[i].y + tgL.y / tgL.x * values[i].x) / tmp;
                if (x > values[i].x && x < values[i + 1].x) {
                    if (tgL.y > 0.0) {
                        if (l1 > l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    } else {
                        if (l1 < l2)
                            l1 = 0.0;
                        else
                            l2 = 0.0;
                    }
                }
            }
        }
        tmpPoint = Point2DMultiply(&tgL , l1);
        bezier[i].points[1] = Point2DAdd(&bezier[i].points[1],&tmpPoint);
        tmpPoint = Point2DMultiply(&tgR , l2);
        bezier[i].points[2] = Point2DSubtract(&bezier[i].points[2],&tmpPoint);
    }
 
    l1 = fabs(tgL.x) > DBL_EPSILON ? (values[n + 1].x - values[n].x) / (2.0 * tgL.x) : 1.0;
 
    bezier[n].points[0] = bezier[n].points[1] = values[n];
    bezier[n].points[2] = bezier[n].points[3] = values[n + 1];
    tmpPoint = Point2DMultiply(&tgR , l1);
    bezier[n].points[1] = Point2DAdd(& bezier[n].points[1],&tmpPoint);
 
    return true;
}
 
int main()
{
 
    Point2D values[POINTS_LEN] =
    {
        {0.0, 0.0},
        {20.0, 0.0},
        {45.0, -47.0},
        {53.0, 335.0},
        {57.0, 26.0},
        {62.0, 387.0},
        {74.0, 104.0},
        {89.0, 0.0},
        {95.0, 100.0},
        {100.0, 0.0}
    };
 
    Segment spline[100];
 
    Point2D p = {0.0,0.0};
 
 
    CalculateSpline(values,POINTS_LEN, spline);
 
    for(int i = 0; i < POINTS_LEN - 1; i++) {
        for (int j = 0; j < RESOLUTION; j++) {
            SegmentCalc(&spline[i],(double)j / (double)RESOLUTION, &p);
            printf("%lf %lf\n", p.x, p.y);
        }
    }
 
    printf("%lf %lf\n", values[POINTS_LEN - 1].x,values[POINTS_LEN - 1].y);
 
    return 0;
}
1
14 / 7 / 2
Регистрация: 25.03.2014
Сообщений: 90
03.06.2017, 20:50  [ТС] 5
В коде было найдено и устранено несколько алгоритмических ошибок. Доработка продолжается.
Публично доступные версии на С++ и чистом Си: https://github.com/eitijupaeno... erpolation
0
03.06.2017, 20:50
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
 03.06.2017, 20:50
Помогаю со студенческими работами здесь

Чистый код
Накипело... Меня бесит неотформатированный грязный код. Я понимаю, что нет времени и/или...

Где найти чистый дистрибутив Windows 7 ? (Ну может и не совсем чистый)
Помогите найти дистрибутив Windows 7 с данными параметрами ! 1)Полностью чистый но с...

чистый код или visual
Builder - понятно.А Visual C++ плохо справляется, или только в ASP? и все таки, какой вид имеет...

Насколько чистый мой код?
Решил я попрактиковаться и написать калькулятор на С++. Ну очень простой, вроде компилится. Я...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
5
Ответ Создать тему
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru