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

@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);
пс: можно еще не как методы класса реализовать, а как просто функции двух аргументов. Так даже логичнее будет.
ппс: часто длина имени функции, класса и прочего не особо мала, особенно чем больше библиотека/АПИ. Ясные, хоть и длинные названия скорее способствуют облегчению восприятия чужого кода.

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Обработчик клика мыши в браузере ПК и касания экрана в браузере на мобильном устройстве 8Observer8 02.02.2026 Содержание блога Для начала пошагово создадим рабочий пример для подготовки к экспериментам в браузере ПК и в браузере мобильного устройства. Потом напишем обработчик клика мыши и обработчик. . .	Философия технологии iceja 01.02.2026 На мой взгляд у человека в технических проектах остается роль генерального директора. Все остальное нейронки делают уже лучше человека. Они не могут нести предпринимательские риски, не могут. . .	SDL3 для Web (WebAssembly): Вывод текста со шрифтом TTF с помощью SDL3_ttf 8Observer8 01.02.2026 Содержание блога В этой пошаговой инструкции создадим с нуля веб-приложение, которое выводит текст в окне браузера. Запустим на Android на локальном сервере. Загрузим Release на бесплатный. . .	SDL3 для Web (WebAssembly): Сборка C/C++ проекта из консоли 8Observer8 30.01.2026 Содержание блога Если вы откроете примеры для начинающих на официальном репозитории SDL3 в папке: examples, то вы увидите, что все примеры используют следующие четыре обязательные функции, а. . .
SDL3 для Web (WebAssembly): Установка Emscripten SDK (emsdk) и CMake для сборки C и C++ приложений в Wasm 8Observer8 30.01.2026 Содержание блога Для того чтобы скачать Emscripten SDK (emsdk) необходимо сначало скачать и уставить Git: Install for Windows. Следуйте стандартной процедуре установки Git через установщик. . . .	SDL3 для Android: Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 29.01.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами. Версия v3 была полностью переписана на Си, в. . .	Инструменты COM: Сохранение данный из VARIANT в файл и загрузка из файла в VARIANT bedvit 28.01.2026 Сохранение базовых типов COM и массивов (одномерных или двухмерных) любой вложенности (деревья) в файл, с возможностью выбора алгоритмов сжатия и шифрования. Часть библиотеки BedvitCOM Использованы. . .	SDL3 для Android: Загрузка PNG с альфа-каналом с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 28.01.2026 Содержание блога SDL3 имеет собственные средства для загрузки и отображения PNG-файлов с альфа-каналом и базовой работы с ними. В этой инструкции используется функция SDL_LoadPNG(), которая. . .

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

	Как бы это декларировать? 21.11.2012, 18:31. Показов 1318. Ответов 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