下列运算符函数中，肯定不属于类Vector 的成员函数的是（ C ）。 A． Vector operator+(Vector); B. Vector operator-(Vector, Vector); C． Vector operator*(int); D. Vector operator/(Vector);

正确的是 C，因为它是一个类外的运算符函数，不属于类 `Vector` 的成员函数。

A 中的 `+` 运算符重载函数是一个类的成员函数，用于实现向量加法，它需要一个 `Vector` 类型的参数，表示要与当前向量相加的向量，返回值为一个 `Vector` 类型的结果向量。

B 中的 `-` 运算符重载函数是一个类外的函数，它需要两个 `Vector` 类型的参数，表示要进行相减的两个向量，返回值为一个 `Vector` 类型的结果向量。

D 中的 `/` 运算符重载函数是一个类的成员函数，用于实现向量除法，它需要一个 `Vector` 类型的参数，表示要除以当前向量的向量，返回值为一个 `Vector` 类型的结果向量。

因此，答案是 C。

相关问题

class Vector3 { public: Vector3(); Vector3(double x,double y,double z); public: Vector3 operator+(const Vector3 &A)const; Vector3 operator++(); friend Vector3 operator-(const Vector3 &v1, const Vector3 &v2); friend Vector3 operator--(Vector3 &v); void display()const; private: double m_x; double m_y; double m_z; }; Vector3::Vector3() :m_x(0.0), m_y(0.0), m_z(0.0) {} Vector3::Vector3(double x, double y,double z) : m_x(x), m_y(y), m_z(z) {} //运算符重载 Vector3 Vector3::operator+(const Vector3 &A) const { Vector3 B; B.m_x = this->m_x + A.m_x; B.m_y = this->m_y + A.m_y; B.m_z = this->m_z + A.m_z; return B; } Vector3 Vector3::operator++() { this->m_x ++; this->m_y ++; this->m_z ++; return *this; } void Vector3::display()const { cout<<"(" << m_x << "," << m_y << "," << m_z << ")" << endl; } Vector3 operator-(const Vector3 &v1,const Vector3 &v2) { Vector3 B(v1.m_x - v2.m_x, v1.m_y - v2.m_y, v1.m_z - v2.m_z); return B; } Vector3 operator--( Vector3 &v) { v.m_x--; v.m_y--; v.m_z --; return v; } int main() { Vector3 v1(1, 2, 3); Vector3 v2(2, 3, 2); ++v1;//v1.operator++(); 作为类成员函数可以显式调用 v1.display(); --v2; v2.display(); Vector3 v3 = v1 + v2;// v1.operator+(v2);作为类成员函数可以显式调用 v3.display(); Vector3 v4 = v1 - v2; v4.display(); return 0; }分析一下这段代码，可以将两个友元函数改为类成员函数吗？

可以将两个友元函数改为类成员函数，具体实现如下：

class Vector3 { 
public: 	
    Vector3(); 	
    Vector3(double x,double y,double z); 
    Vector3 operator+(const Vector3 &A)const; 	
    Vector3 operator++(); 	
    Vector3 operator--(); 
    Vector3 operator-(const Vector3 &A) const;
    void display() const; 
private: 	
    double m_x; 	
    double m_y; 	
    double m_z; 
}; 

Vector3 Vector3::operator+(const Vector3 &A) const { 
    Vector3 B; 	
    B.m_x = this->m_x + A.m_x; 	
    B.m_y = this->m_y + A.m_y; 	
    B.m_z = this->m_z + A.m_z; 	
    return B; 
} 

Vector3 Vector3::operator++() { 
    this->m_x ++; 	
    this->m_y ++; 	
    this->m_z ++; 	
    return *this; 
} 

Vector3 Vector3::operator--() { 
    this->m_x --; 	
    this->m_y --; 	
    this->m_z --; 	
    return *this; 
} 

Vector3 Vector3::operator-(const Vector3 &A) const { 
    Vector3 B; 	
    B.m_x = this->m_x - A.m_x; 	
    B.m_y = this->m_y - A.m_y; 	
    B.m_z = this->m_z - A.m_z; 	
    return B; 
} 

void Vector3::display() const { 
    cout << "(" << m_x << "," << m_y << "," << m_z << ")" << endl; 
}

其中，将 `operator-` 和 `operator--` 改为了成员函数，并且将 `operator-` 的参数名改为了 `A`，来避免与 `operator--` 的参数名冲突。

4.设计一个三维向量类Vector。该类包含有三个float类型的数据成员x、y、z，用于表示向量的三维；该类还包含一些函数成员，具体如下： 1）Vector类包含两个构造函数。第一个为无参数构造函数，该函数能将向量的三个数据成员均初始化为0；第二个构造函数带有三个float型的数据成员(v1、v2、v3)，其值分别用于初始化x、y、z； 2）Vector类包含有一个成员函数Print，用于显示该向量； 3）Vector类中重载运算符+和-，完成两个向量的相加和相减运算，以成员函数的方式重载； 4）Vector类中重载运算符+和-，完成向量与浮点数的相加和相减运算，以友元函数的方式重载； 5）Vector类中重载运算符*，完成向量的点乘运算，以友元函数的形式重载； 在main函数中编写测试代码，测试这几个成员函数，通过Print函数显示运算结果。

以下是实现上述要求的Vector类的示例代码：

#include <iostream>
using namespace std;

class Vector {
private:
    float x, y, z;

public:
    Vector() : x(0), y(0), z(0) {} // 无参数构造函数

    Vector(float v1, float v2, float v3) : x(v1), y(v2), z(v3) {} // 带参数构造函数

    void Print() {
        cout << "(" << x << ", " << y << ", " << z << ")" << endl;
    }

    Vector operator+(const Vector& other) {
        Vector result;
        result.x = this->x + other.x;
        result.y = this->y + other.y;
        result.z = this->z + other.z;
        return result;
    }

    Vector operator-(const Vector& other) {
        Vector result;
        result.x = this->x - other.x;
        result.y = this->y - other.y;
        result.z = this->z - other.z;
        return result;
    }

    friend Vector operator+(const Vector& vec, float scalar) {
        Vector result;
        result.x = vec.x + scalar;
        result.y = vec.y + scalar;
        result.z = vec.z + scalar;
        return result;
    }

    friend Vector operator-(const Vector& vec, float scalar) {
        Vector result;
        result.x = vec.x - scalar;
        result.y = vec.y - scalar;
        result.z = vec.z - scalar;
        return result;
    }

    friend float operator*(const Vector& vec1, const Vector& vec2) {
        return vec1.x * vec2.x + vec1.y * vec2.y + vec1.z * vec2.z;
    }
};

int main() {
    Vector v1; // 使用无参数构造函数创建向量
    v1.Print(); // 输出 (0, 0, 0)

    Vector v2(1.0f, 2.0f, 3.0f); // 使用带参数构造函数创建向量
    v2.Print(); // 输出 (1, 2, 3)

    Vector v3 = v1 + v2; // 向量相加
    v3.Print(); // 输出 (1, 2, 3)

    Vector v4 = v2 - v1; // 向量相减
    v4.Print(); // 输出 (1, 2, 3)

    Vector v5 = v1 + 2.0f; // 向量与浮点数相加
    v5.Print(); // 输出 (2, 2, 2)

    Vector v6 = v2 - 1.0f; // 向量与浮点数相减
    v6.Print(); // 输出 (0, 1, 2)

    float dotProduct = v1 * v2; // 向量点乘
    cout << "Dot Product: " << dotProduct << endl; // 输出 Dot Product: 0

    return 0;
}

该示例代码定义了一个Vector类，包含了所需的构造函数、Print函数和重载的运算符。在主函数中进行了一系列测试，验证了Vector类的功能。