Как бы это декларировать?

@taras atavin · Регистрация: 24.11.2009

Студворк — интернет-сервис помощи студентам

Вектор должен поддерживать и скалярное, и векторное произведение.

Добавлено через 1 минуту
Реализация - не проблема, проблема в том, что символ умножения в c++ один, а в обоих случаях оба параметра имеют тип Vector. Нельзя же перегрузить на тип значения.

@NEW_NAME · 21.11.2012, 18:56

А зачем делать перегрузку *? Это же вобщем-то такие операции, которые не особо однозначны умножению в случае чисел. Вообще логично две функции отдельные завести.

@OhMyGodSoLong · 21.11.2012, 21:23

Сообщение от NEW_NAME

А зачем делать перегрузку *? Это же вобщем-то такие операции, которые не особо однозначны умножению в случае чисел. Вообще логично две функции отдельные завести.

this

Если уж совсем очень капец как хочется именно операторы, то сделайте, например, * для скалярного и % для векторного. Но это неочевидно.

@taras atavin · 22.11.2012, 08:27 **[ТС]**

И как лучше назвать эти методы?

@gray_fox · 22.11.2012, 09:21

scalar_product, inner_product ?

@SatanaXIII · 22.11.2012, 09:54

Сообщение от ~OhMyGodSoLong~

* для скалярного и %

"*" и "х"

@gray_fox · 22.11.2012, 10:00

Сообщение от SatanaXIII

х

Нет же такого оператора, ^ уж тогда)

@vxg · 22.11.2012, 10:45

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
//------------------------------------------------------------------------------
#ifndef vector_h
#define vector_h
//------------------------------------------------------------------------------
class vector
{
public:
    float x;
    float y;
    float z;
 
    vector(void);
    vector(const float &x, const float &y, const float &z);
    virtual ~vector();
 
    const vector &operator=(const vector &v);
 
    float &operator[](const unsigned index);
    const float &operator[](const unsigned index) const;
 
    bool operator==(const vector &v) const;
    bool operator!=(const vector &v) const;
 
    vector operator-(void) const;
 
    vector operator+(const vector &v) const;
    vector operator-(const vector &v) const;
    vector operator*(const float &c) const;
    float operator*(const vector &v) const; //скалярное умножение
    vector operator^(const vector &v) const; //векторное умножение
    vector operator&(const vector &v) const; //поэлементное умножение
    vector operator/(const float &c) const;
 
    const vector &operator+=(const vector &v);
    const vector &operator-=(const vector &v);
    const vector &operator*=(const float &c);
    const vector &operator^=(const vector &v); //векторное умножение
    const vector &operator&=(const vector &v); //поэлементное умножение
    const vector &operator/=(const float &c);
 
    float module() const;
    const vector &normalize(const float &c = 1);
};
//------------------------------------------------------------------------------
vector operator*(const float &c, const vector &v);
//------------------------------------------------------------------------------
#endif //vector_h

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
//------------------------------------------------------------------------------
#include "vector.h"
//------------------------------------------------------------------------------
#include <math.h>
#include <stdlib.h>
//------------------------------------------------------------------------------
vector::vector(void)
    : x(0),
      y(0),
      z(0)
{}
//------------------------------------------------------------------------------
vector::vector(const float &x, const float &y, const float &z)
    : x(x),
      y(y),
      z(z)
{}
//------------------------------------------------------------------------------
vector::~vector()
{}
//------------------------------------------------------------------------------
const vector &vector::operator=(const vector &v)
{
    if (this != &v)
    {
        x = v.x;
        y = v.y;
        z = v.z;
    }
 
    return *this;
}
//------------------------------------------------------------------------------
float &vector::operator[](const unsigned index)
{
    return *(&x + index);
}
//------------------------------------------------------------------------------
const float &vector::operator[](const unsigned index) const
{
    return *(&x + index);
}
//------------------------------------------------------------------------------
bool vector::operator==(const vector &v) const
{
    return x == v.x && y == v.y && z == v.z;
}
//------------------------------------------------------------------------------
bool vector::operator!=(const vector &v) const
{
    return x != v.x || y != v.y || z != v.z;
}
//------------------------------------------------------------------------------
vector vector::operator-(void) const
{
    return vector(-x, -y, -z);
}
//------------------------------------------------------------------------------
vector vector::operator+(const vector &v) const
{
    return vector(x + v.x, y + v.y, z + v.z);
}
//------------------------------------------------------------------------------
vector vector::operator-(const vector &v) const
{
    return vector(x - v.x, y - v.y, z - v.z);
}
//------------------------------------------------------------------------------
vector vector::operator*(const float &c) const
{
    return vector(x * c, y * c, z * c);
}
//------------------------------------------------------------------------------
float vector::operator*(const vector &v) const
{
    return x * v.x + y * v.y + z * v.z;
}
//------------------------------------------------------------------------------
vector vector::operator^(const vector &v) const
{
    return vector
    (
        y * v.z - z * v.y,
        z * v.x - x * v.z,
        x * v.y - y * v.x
    );
}
//------------------------------------------------------------------------------
vector vector::operator&(const vector &v) const
{
    return vector(x * v.x, y * v.y, z * v.z);
}
//------------------------------------------------------------------------------
vector vector::operator/(const float &c) const
{
    return vector(x / c, y / c, z / c);
}
//------------------------------------------------------------------------------
const vector &vector::operator+=(const vector &v)
{
    x += v.x;
    y += v.y;
    z += v.z;
 
    return *this;
}
//------------------------------------------------------------------------------
const vector &vector::operator-=(const vector &v)
{
    x -= v.x;
    y -= v.y;
    z -= v.z;
 
    return *this;
}
//------------------------------------------------------------------------------
const vector &vector::operator*=(const float &c)
{
    x *= c;
    y *= c;
    z *= c;
 
    return *this;
}
//------------------------------------------------------------------------------
const vector &vector::operator^=(const vector &v)
{
    return *this = vector
    (
        y * v.z - z * v.y,
        z * v.x - x * v.z,
        x * v.y - y * v.x
    );
}
//------------------------------------------------------------------------------
const vector &vector::operator&=(const vector &v)
{
    x *= v.x;
    y *= v.y;
    z *= v.z;
 
    return *this;
}
//------------------------------------------------------------------------------
const vector &vector::operator/=(const float &c)
{
    x /= c;
    y /= c;
    z /= c;
 
    return *this;
}
//------------------------------------------------------------------------------
float vector::module() const
{
    return sqrt(fabs(x * x + y * y + z * z));
}
//------------------------------------------------------------------------------
const vector &vector::normalize(const float &c)
{
    return *this /= module() / c;
}
//------------------------------------------------------------------------------
vector operator*(const float &c, const vector &v)
{
    return v * c;
}

@taras atavin · 22.11.2012, 11:01 **[ТС]**

Сообщение от vxg

float module() const;

Модуль принято обозначать функцией abs. Для векторов она определена иначе? Эйси. Ну так и сумма векторов определена иначе. Кроме того,

C++
1
2
3
4
double abs(double x)
{
 rerturn sqrt(x*x);
}

тоже вернёт модуль числа, как он определён для скаляров, но такой вариант есть прямое расширение модуля вектора на скаляры.

Добавлено через 1 минуту

Сообщение от vxg

const vector &vector::operator=(const vector &v)
{
* * if (this != &v)
* * {
* * * * x = v.x;
* * * * y = v.y;
* * * * z = v.z;
* * }
return *this;
}

Я реализацию не просил, а лишние строки снижают читабельность.

@vxg · 22.11.2012, 11:02

Сообщение от taras atavin

Модуль принято обозначать функцией abs

на любителя. модуль вектора - это его длина. к модулю как к абсолютному значению числа отношения не имеет.

Добавлено через 30 секунд

Сообщение от taras atavin

Я реализацию не просил

удали. или пролистай.

@taras atavin · 22.11.2012, 11:04 **[ТС]**

Сообщение от vxg

float operator*(const vector &v) const; //скалярное умножение

Сообщение от vxg

vector operator&(const vector &v) const; //поэлементное умножение

. В чём семантическая разница?

Добавлено через 56 секунд

Сообщение от vxg

float operator*(const vector &v) const; //скалярное умножение
* * vector operator^(const vector &v) const; //векторное умножение

легко забыть, всё таки "^" - не знак умножения.

@vxg · 22.11.2012, 11:09

Сообщение от taras atavin

В чём семантическая разница

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

Добавлено через 56 секунд

Сообщение от taras atavin

легко забыть

это можно сделать с любым знанием. здесь - просто соглашения об использовании. лучше, хуже... хз. работает. корни уходят к книжке "компьютерная графика"

Добавлено через 1 минуту

Сообщение от taras atavin

легко забыть

а в математике не легко забыть что квадратные скобки - векторное умножение)?

@taras atavin · 22.11.2012, 11:57 **[ТС]**

Сообщение от vxg

а в математике не легко забыть что квадратные скобки - векторное умножение)?

ни разу не видел такого обозначения умножения.

@vxg · 22.11.2012, 12:36

Сообщение от taras atavin

ни разу не видел такого обозначения умножения

и это очень странно учитывая ваш интерес к вопросу
http://ru.wikipedia.org/wiki/%... 0%B8%D0%B5

@NEW_NAME · 22.11.2012, 13:38

Просто же:
Vector vectorMultiplication(Vector ass);
double scalarMultiplication(Vector ass);

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

По модулю то же самое: модуль числа и вектора не то же самое, поэтому не зачем путаницу создавать.
Вот суммирование/вычитание перегружать смысл есть.

@vxg · 22.11.2012, 15:00

Сообщение от NEW_NAME

Просто же

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

@NEW_NAME · 22.11.2012, 15:05

ну можно написать:
Vector vectMult(Vector ass);
double scalMult(Vector ass);

или даже:
Vector vMult(Vector ass);
double sMult(Vector ass);
пс: можно еще не как методы класса реализовать, а как просто функции двух аргументов. Так даже логичнее будет.
ппс: часто длина имени функции, класса и прочего не особо мала, особенно чем больше библиотека/АПИ. Ясные, хоть и длинные названия скорее способствуют облегчению восприятия чужого кода.

Новые блоги и статьи Все статьи Все блоги /
Идея фильтра интернета (сервер = слой+фильтр). Hrethgir 31.03.2026 Суть идеи заключается в том, чтобы запустить свой сервер, о чём я если честно мечтал давно и давно приобрёл книгу как это сделать. Но не было причин его запускать. Очумелые учёные напечатали на. . .	Модель здравосоХранения 6. ESG-повестка и устойчивое развитие; углублённый анализ кадрового бренда anaschu 31.03.2026 В прикрепленном документе раздумья о том, как можно поменять модель в будущем	10 пpимет, которые всегда сбываются Maks 31.03.2026 1. Чтобы, наконец, пришла маршрутка, надо закурить. Если сигарета последняя, маршрутка придет еще до второй затяжки даже вопреки расписанию. 2. Нaдоели зима и снег? Не надо переезжать. Достаточно. . .	Перемещение выделенных строк ТЧ из одного документа в другой Maks 31.03.2026 Реализация из решения ниже выполнена на примере нетипового документа "ВыдачаОборудованияНаСпецтехнику" с единственной табличной частью "ОборудованиеИКомплектующие" разработанного в конфигурации КА2. . . .
Functional First Web Framework Suave DevAlt 30.03.2026 Sauve. IO Апнулись до NET10. Из зависимостей один пакет, работает одинаково хорошо как в режиме проекта так и в интерактивном режиме. из сложностей - чисто функциональный подход. Решил. . .	Автоматическое создание документа при проведении другого документа Maks 29.03.2026 Реализация из решения ниже выполнена на нетиповых документах, разработанных в конфигурации КА2. Есть нетиповой документ "ЗаявкаНаРемонтСпецтехники" и нетиповой документ "ПланированиеСпецтехники". В. . .	Настройка движения справочника по регистру сведений Maks 29.03.2026 Решение ниже реализовано на примере нетипового справочника "ТарифыМобильнойСвязи" разработанного в конфигурации КА2, с целью учета корпоративной мобильной связи в коммерческом предприятии. . . .	Автозаполнение реквизита при выборе элемента справочника Maks 27.03.2026 Программный код из решения ниже на примере нетипового документа "ЗаявкаНаРемонтСпецтехники" разработанного в конфигурации КА2. При выборе "Спецтехники" (Тип Справочник. Спецтехника), заполняется. . .

@taras atavin 4226 / 1796 / 211 Регистрация: 24.11.2009 Сообщений: 27,562

	Как бы это декларировать? 21.11.2012, 18:31. Показов 1358. Ответов 16 Метки нет (Все метки) Вектор должен поддерживать и скалярное, и векторное произведение. Добавлено через 1 минуту Реализация - не проблема, проблема в том, что символ умножения в c++ один, а в обоих случаях оба параметра имеют тип Vector. Нельзя же перегрузить на тип значения. 0

@NEW_NAME 1 / 1 / 1 Регистрация: 04.10.2012 Сообщений: 45
	21.11.2012, 18:56
	А зачем делать перегрузку *? Это же вобщем-то такие операции, которые не особо однозначны умножению в случае чисел. Вообще логично две функции отдельные завести. 0

@taras atavin 4226 / 1796 / 211 Регистрация: 24.11.2009 Сообщений: 27,562
	22.11.2012, 08:27 [ТС]
	И как лучше назвать эти методы? 0

@gray_fox What a waste! 1610 / 1302 / 180 Регистрация: 21.04.2012 Сообщений: 2,733
	22.11.2012, 09:21
	scalar_product, inner_product ? 0

@NEW_NAME 1 / 1 / 1 Регистрация: 04.10.2012 Сообщений: 45
	22.11.2012, 13:38
	Просто же: Vector vectorMultiplication(Vector ass); double scalarMultiplication(Vector ass); Если бы кто-то начал пользоваться этим классом, то по перегрузке * он бы не понял какое конкретно это умножение без чтения комментариев, а про ^ он бы может и не догадался бы. А такое название функций говорит само за себя. По модулю то же самое: модуль числа и вектора не то же самое, поэтому не зачем путаницу создавать. Вот суммирование/вычитание перегружать смысл есть. 0

@NEW_NAME 1 / 1 / 1 Регистрация: 04.10.2012 Сообщений: 45
	22.11.2012, 15:05
	ну можно написать: Vector vectMult(Vector ass); double scalMult(Vector ass); или даже: Vector vMult(Vector ass); double sMult(Vector ass); пс: можно еще не как методы класса реализовать, а как просто функции двух аргументов. Так даже логичнее будет. ппс: часто длина имени функции, класса и прочего не особо мала, особенно чем больше библиотека/АПИ. Ясные, хоть и длинные названия скорее способствуют облегчению восприятия чужого кода. 0