C++ Day4

已于 2023-08-25 19:34:34 修改
阅读量291 收藏
点赞数
分类专栏： 转世重生 文章标签： c++ 开发语言
于 2023-08-24 20:40:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ck0056/article/details/132482035
版权

目录

一、拷贝赋值函数

1.1 作用

1.2 格式

二、匿名对象

 2.2 格式

三、友元

3.1作用

3.2格式

3.3 种类

3.4 全局函数做友元

 3.5类做友元

 3.6 成员函数做友元

3.7注意

四、常成员函数和常对象

4.1 常成员函数

4.1.1格式

示例： 

4.2 常对象

作用：

格式：

 示例：

4.3 mutable关键字

五、运算符重载

5.1概念

5.2 算术运算符的重载

 1.成员函数实现：

5.3 关系运算符的重载

5.4 赋值运算符重载

5.5自增、自减运算符重载

自增为例：

1）前置自增

2）后置自增

5.6插入、提取运算符重载

5.7 不能重载的运算符

作业：实现关系运算符的重载

一、拷贝赋值函数

1.1 作用

用一个对象给另一个对象赋值。

1.2 格式

一、拷贝赋值函数
1.1 作用
用一个对象给另一个对象赋值。
1.2 格式

封装学生的类，写出构造函数，析构函数、拷贝构造函数、拷贝赋值函数

#include <iostream>


using namespace std;


//封装 学生 类
class Stu
{
private:
    string name;
    int age;
public:
    //无参构造函数
    Stu() {cout << "无参构造函数" << endl;}


    //有参构造函数
    Stu(string name, int age):name(name),age(age)
    {cout << "有参构造函数" << endl;}


    //拷贝构造函数
    Stu(const Stu& other):name(other.name)
    {
        this->age = other.age;
        cout << "拷贝构造函数" << endl;
    }


    //拷贝赋值函数
    Stu & operator=(const Stu& other)
    {
        if(this != &other)  //避免自己给自己赋值
        {
            
            this->name = other.name;
            age = other.age;
            cout << "拷贝赋值函数"  << endl;
            
            
        }
            
            return *this;  //返回自己
        
    }
    ~Stu()
    {
        cout << "析构函数" << endl;
    }
    void display()
    {
        cout << name << endl;
    }
};




int main()
{
    Stu s1("zhangsan",12);
    s1.display();


    Stu s2 = s1;  // s2.Stu(s1)
    s2.display();


    Stu s3;
    s3 = s1;  //s3.operator=(s1)
    s3.display();


    return 0;
}

二、匿名对象

匿名对象就是没有名字的对象

用处：

1.用匿名对象给有名对象初始化

2.用匿名对象个对象数组初始化

3.用匿名对象做函数实参。

 2.2 格式

类名()

#include <iostream>

using namespace std;

class Stu
{
private:
    string name;
    int age;
public:
    //无参构造
    Stu() {}

    //有参构造
    Stu(string name,int age):name(name),age(age)
    {}
    void show()
    {
        cout << name << endl;
        cout << age << endl;
    }
};
void fun(Stu s)  //Stu s = Stu("lisi",23)
{
    s.show();
}

int main()
{
    Stu s1 = Stu("zhangsan",34);  //用匿名对象给有名对象初始化
    s1.show();

    Stu s[3] = {Stu("a",2),Stu("b",4),Stu("c",4)};

    fun(Stu("lisi",23)); //匿名对象做函数的实参
    return 0;
}

三、友元

3.1作用

友元，让一个函数或者类，访问另一个类的私有数据成员

3.2格式

friend xxxxxx

3.3 种类

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

3.4 全局函数做友元

#include <iostream>


using namespace std;


//封装 房间 类
class Room
{
    friend void goodGay(Room &r);//goodGay函数是本类的好朋友，可以访问本类的所有成员


    
private:
    string m_BedRoom;  //卧室
public:
    string m_SittingRoom; //客厅
public:
    //无参
    Room()
    {
        m_BedRoom = "卧室";
        m_SittingRoom = "客厅";
    }


};




//全局函数做友元
void goodGay(Room &r)
{
    cout << "好基友函数正在访问。。"  << r.m_SittingRoom << endl;
    cout << "好基友函数正在访问。。"  << r.m_BedRoom << endl;
}


int main()
{
    Room r;
    goodGay(r);




    return 0;
}

 3.5类做友元

#include <iostream>


using namespace std;


//封装 房间 类
class Room
{


    friend class GoodGay;  //GoodGay这个类是本类的好朋友。可以访问本类的所有成员
private:
    string m_BedRoom;  //卧室
public:
    string m_SittingRoom; //客厅
public:
    //无参
    Room()
    {
        m_BedRoom = "卧室";
        m_SittingRoom = "客厅";
    }


};


//类做友元
class GoodGay
{
public:
    Room *r;
    void visit()
    {
        cout << "好基友类正在访问。。" << r->m_SittingRoom << endl;
        cout << "好基友类正在访问。。"  << r->m_BedRoom << endl;
    }


    GoodGay()
    {
        r = new Room;
    }
};




int main()
{


    GoodGay g;
    g.visit();


    return 0;
}

 3.6 成员函数做友元

#include <iostream>

using namespace std;


class Room;//声明有这样的类


//类做友元
class GoodGay
{
public:
    Room *r;
    void visit();//在类内声明
    GoodGay();


};


//封装 房间 类
class Room
{
    friend void GoodGay::visit();  //这个类的成员函数是本类的好朋友。可以访问本类所有成员
private:
    string m_BedRoom;  //卧室
public:
    string m_SittingRoom; //客厅
public:
    //无参
    Room()
    {
        m_BedRoom = "卧室";
        m_SittingRoom = "客厅";
    }


};


void GoodGay::visit()  //在类外定义成员函数
{
     cout << "好基友类正在访问。。" << r->m_SittingRoom << endl;
     cout << "好基友类正在访问。。"  << r->m_BedRoom << endl;
}
GoodGay::GoodGay()
{
    r = new Room;
}


int main()
{


    GoodGay g;
    g.visit();


    return 0;
}

3.7注意

1.不要过度的使用友元，会降低封装性。

2.友元不具有交换性、传递性、继承性。

四、常成员函数和常对象

热知识：

const int a = 10; //a不能被改变

int const *p; //指针的指向可变，指向里的值不可变

int * const p; // 指针的指向不可变，指向里的值可变

int const * const p; //都不可变

const int fun(){}  //返回值是不可以被改变的

4.1 常成员函数

所有非常成员函数，都可以对数据成员进行修改，如果想让一个成员函数不能对数据成员修改，那么就要用到常成员函数实现。

4.1.1格式

函数返回值类型 函数名(形参列表)  const
{
    
}

示例： 

#include <iostream>

using namespace std;
//封装 学生 类

class Stu
{
private:
    string name;
    int age;

public:
    //无参构造函数
    Stu() {}
    
    //有参构造函数
    Stu(string n, int a):name(n),age(a)
    {}

    void show() const
    {
        //age = 78;  常成员函数不能修改数据成员的值
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
};
int main()
{
    Stu s("zhangsan",3);
    s.show();

    return 0;
}

4.2 常对象

作用：

常对象，表明这个对象的所有数据成员不能被改变。

常对象只能调用常成员函数，如果没有常成员函数，则报错。

非常对象对于常成员函数和非常成员函数都可以调用，优先非常成员函数。

常成员函数和非常成员函数构成重载，原因this指针类型不同。

格式：

const 类名 对象名;

 示例：

#include <iostream>

using namespace std;

//封装 学生 类
class Stu
{
private:
    string name;
    int age;
    
public:

    //无参构造函数
    Stu() {}

    //有参构造函数
    Stu(string n, int a):name(n),age(a)
    {}

    //常成员函数
    void show() const  //Stu const * const this   都不可变
    {
        //age = 78;  常成员函数不能修改数据成员的值
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }

    //非常成员函数
    void show()   // Stu * const this  指向不可变 指向的值可以变
    {
        age = 78;
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }
};

int main()
{
   //非常对象
    Stu s("zhangsan",3);
    s.show();

    //常对象
    const Stu s1("lisi",4);
    s1.show();
    return 0;
}

4.3 mutable关键字

  • mutable修饰变量 ---取消常属性
  • mutable修饰数据成员，表示该数据可以在常成员函数中被修改

#include <iostream>

using namespace std;
//封装 学生 类

class Stu
{
private:
    string name;
    mutable int age;  //在常成员函数中可以被修改
public:
    //无参构造函数
    Stu() {}

    //有参构造函数
    Stu(string n, int a):name(n),age(a)
    {}

    //常成员函数
    void show() const  //Stu const * const this   都不可变
    {
        age = 78;  //常成员函数不能修改数据成员的值
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
    }


//    //非常成员函数
//    void show()   // Stu * const this  指向不可变 指向的值可以变
//    {
//        age = 78;
//        cout << "姓名：" << name << endl;
//        cout << "年龄：" << age << endl;
//    }
};

int main()
{
   //非常对象
    Stu s("zhangsan",3);
    s.show();

//    //常对象
//    const Stu s1("lisi",4);
//    s1.show();
    return 0;
}

五、运算符重载

5.1概念

运算符重载 就是对运算符重新定义，赋予另一种功能，以适应不同的数据类型。

每个运算符重载都有两种实现方式：成员函数实现运算符重载、全局函数实现运算符重载

5.2 算术运算符的重载

  • 种类：+ - * / %
  • 表达式： L # R ( L:左操作数 #运算符 R: 右操作数)
  • 左操作数：可以是左值，也可以是右值，在运算过程中 不会被改变
  • 右操作数：可以是左值，也可以是右值，在运算过程中 不会被改变
  • 结果：右值 （不可以被改变）
  • 实现方式

 1.成员函数实现：


const 类名 operator#(const 类名 &R) const

{}

// 1. cosnt 运算结果不能被改变

2.cosnt 右操作数在运算过程中，不能被改变

3.cosnt 左操作数在运算过程中，不能被改变

2.全局函数实现：

const 类名 operator#(const 类名 &L, const 类名 &R)

{}

#include <iostream>

using namespace std;

//封装人  类
class Person
{
    friend const Person operator+(const Person &L, const Person &R);
private:
    int a;
    int b;
public:
    //无参构造函数
    Person() {}

    //有参构造函数
    Person(int a, int b):a(a),b(b)
    {}

    //成员函数实现 + 号运算符重载
//    const Person operator+(const Person &R) const
//    {
//        Person temp;
//        temp.a = a + R.a;
//        temp.b = b + R.b;

//        return temp;
//    }

    void display()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
    }
};

//全局函数实现+号运算符重载
const Person operator+(const Person &L, const Person &R)
{
    Person temp;
    temp.a = L.a + R.a;
    temp.b = L.b + R.b;

    return temp;

}

int main()
{
    Person p1(10,10);
    Person p2(10,10);

    //简化成：
    //Person p3 = p1 + p2;  //本质： p3 = p1.operator+(p2)
    Person p3 = p1 + p2;  //本质： p3 = operator+(p1,p2)


    p3.display();

    //Person p4 = p1.operator+(p2);
    //p4.display();



    return 0;
}

5.3 关系运算符的重载

1> 种类：> >= <

2> 表达式： L # R ( L:左操作数 #运算符 R: 右操作数)

3> 左操作数：可以是左值，也可以是右值，在运算过程中 不会被改变

4> 右操作数：可以是左值，也可以是右值，在运算过程中 不会被改变

5> 结果：bool类型

6> 实现方式

1.成员函数实现：
         bool operator#(const 类名 &R) const
 {}
// 1. cosnt 运算结果不能被改变
    2.cosnt 右操作数在运算过程中，不能被改变
    3.cosnt 左操作数在运算过程中，不能被改变
2.全局函数实现：
       bool operator#(const 类名 &L, const 类名 &R)
      {}

5.4 赋值运算符重载

1> 种类：= 、+=、-=、*=、/=、%=

2> 表达式： L # R ( L:左操作数 #运算符 R: 右操作数)

3> 左操作数：只能是左值

4> 右操作数：可以是左值，也可以是右值，在运算过程中 不会被改变

5> 结果：自身的引用

6> 实现方式

1.成员函数实现：
         类名 & operator#(const 类名 &R)
 {}
   
2.全局函数实现：
       类名 &  operator#(类名 &L, const 类名 &R)
      {}

5.5自增、自减运算符重载

自增为例：

1）前置自增

1.表达式 ：++O

2.操作数：左值，运算过程中要被改变

3.结果：自身的引用

4.实现方式：
      成员函数实现：  类名 & operator++()
      全局函数实现：   类名 & operator++(类名 &O)

2）后置自增

1.表达式 ：O++

2.操作数：左值，运算过程中要被改变

3.结果：右值 （不可以被改变）

4.实现方式：
      成员函数实现：  const 类名 operator++(int)
      全局函数实现：   const 类名 operator++(类名 &O,int)
#include <iostream>

using namespace std;

//封装人  类
class Person
{
//    friend const Person operator+(const Person &L, const Person &R);
    friend Person & operator+=(Person &L, const Person &R);
private:
    int a;
    int b;
public:
    //无参构造函数
    Person() {}

    //有参构造函数
    Person(int a, int b):a(a),b(b)
    {}

    Person(const Person& p):a(p.a),b(p.b)
    {

    }

    //成员函数实现 + 号运算符重载
    const Person operator+(const Person &R) const
    {
        Person temp;
        temp.a = a + R.a;
        temp.b = b + R.b;

        return temp;
    }

    //成员函数实现 >浩运算符重载
    bool operator>(const Person &R)
    {
        if(a>R.a && b>R.b)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //成员函数实现+=运算符重载
//    Person & operator+=(const Person &R)
//    {
//        a += R.a; // a = a + R.a;
//        b += R.b;
//        return *this;
//    }

    //成员函数实现前++运算符重载
    Person & operator++()
    {
        ++a;
        ++b;
        return *this;
    }

    //成员函数实现后++运算符重载
    const Person operator++(int)  //区别前置自增
    {
        Person temp;
        temp.a = a++;
        temp.b = b++;
        return temp;
    }

    void display()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
    }
};

全局函数实现+号运算符重载
//const Person operator+(const Person &L, const Person &R)
//{
//    Person temp;
//    temp.a = L.a + R.a;
//    temp.b = L.b + R.b;

//    return temp;
//}


//全局函数实现+=运算符重载
Person & operator+=(Person &L, const Person &R)
{
    L.a += R.a;
    L.b += R.b;
    return L;
}

int main()
{
    Person p1(10,10);
    Person p2(10,10);

    //简化成：
    //Person p3 = p1 + p2;  //本质： p3 = p1.operator+(p2)
    Person p3 = p1 + p2;  //本质： p3 = operator+(p1,p2)

    p3.display();

    //Person p4 = p1.operator+(p2);
    //p4.display();

    if(p3>p1)
    {
        cout << "p3>p1" << endl;
    }

    cout << "=======================" << endl;

    Person p4(3,4);
    p4 += p1;
    p4.display();

    cout << "=======================" << endl;

    p1 = ++p4;
    p1.display();
    p4.display();

    cout << "=======================" << endl;

    Person p5(7,8);
    p2 = p5++;
    p2.display();
    p5.display();



    return 0;
}

5.6插入、提取运算符重载

插入 >

cout 是 ostream 类的对象

cin 是 istream 类的对象

#include <iostream>

using namespace std;

//封装人  类
class Person
{
//    friend const Person operator+(const Person &L, const Person &R);
    friend Person & operator+=(Person &L, const Person &R);
    friend ostream & operator<<(ostream &cout, const Person &p);
    friend istream & operator>>(istream &cin, Person &p);
private:
    int a;
    int b;
public:
    //无参构造函数
    Person() {}

    //有参构造函数
    Person(int a, int b):a(a),b(b)
    {}

    Person(const Person& p):a(p.a),b(p.b)
    {

    }

    //成员函数实现 + 号运算符重载
    const Person operator+(const Person &R) const
    {
        Person temp;
        temp.a = a + R.a;
        temp.b = b + R.b;

        return temp;
    }

    //成员函数实现 >浩运算符重载
    bool operator>(const Person &R)
    {
        if(a>R.a && b>R.b)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //成员函数实现+=运算符重载
//    Person & operator+=(const Person &R)
//    {
//        a += R.a; // a = a + R.a;
//        b += R.b;
//        return *this;
//    }

    //成员函数实现前++运算符重载
    Person & operator++()
    {
        ++a;
        ++b;
        return *this;
    }

    //成员函数实现后++运算符重载
    const Person operator++(int)  //区别前置自增
    {
        Person temp;
        temp.a = a++;
        temp.b = b++;
        return temp;
    }

    void display()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
    }
};

全局函数实现+号运算符重载
//const Person operator+(const Person &L, const Person &R)
//{
//    Person temp;
//    temp.a = L.a + R.a;
//    temp.b = L.b + R.b;

//    return temp;
//}


//全局函数实现+=运算符重载
Person & operator+=(Person &L, const Person &R)
{
    L.a += R.a;
    L.b += R.b;
    return L;
}

//全局函数实现插入运算符重载
ostream & operator<<(ostream &cout, const Person &p)
{
    cout << p.a << endl;
    cout << p.b << endl;
    return cout;
}

//全局函数实现提取运算符重载
istream & operator>>(istream &cin, Person &p)
{
   cin >> p.a;
   cin >> p.b;
   return cin;
}

int main()
{
    Person p1(10,10);
    Person p2(10,10);

    //简化成：
    //Person p3 = p1 + p2;  //本质： p3 = p1.operator+(p2)
    Person p3 = p1 + p2;  //本质： p3 = operator+(p1,p2)

    p3.display();

    //Person p4 = p1.operator+(p2);
    //p4.display();

    if(p3>p1)
    {
        cout << "p3>p1" << endl;
    }

    cout << "=======================" << endl;

    Person p4(3,4);
    p4 += p1;
    p4.display();

    cout << "=======================" << endl;

    p1 = ++p4;
    p1.display();
    p4.display();

    cout << "=======================" << endl;

    Person p5(7,8);
    p2 = p5++;
    p2.display();
    p5.display();


    cout << "=======================" << endl;
    // operator<<(cout,p2)
    cout << p2 << endl;  //本质   cout.perator<<(p2)
                         //全局函数本质 operator<<(cout,p2)
                         // ostream &   operator<<(ostream &cout,const Person &p)


    cout << "=======================" << endl;
    Person p6;
    cin >> p6;  //cin.operator>>(p2)
                // operator>>(cin,p6)
                // istream & operator>>(istream &cin, Person & p)
    cout << p6;




    return 0;
}

5.7 不能重载的运算符

  • 成员运算符 .
  • 成员指针运算符 ->
  • 作用域限定符 ::
  • 计算字节大小 sizeof()
  • 三目运算符 ? :

作业：实现关系运算符的重载

#include <iostream>

using namespace std;

class Stu{
    int a;
public:
    Stu(){}

    Stu(int a): a(a)
    {

    }
    //成员函数实现+号运算符重载
    bool operator > (const  Stu &R) const
    {
        return a > R.a;
    }
    bool operator >= (const  Stu &R) const
    {
        return a >= R.a;
    }
    bool operator < (const  Stu &R) const
    {
        return a < R.a;
    }
    bool operator <= (const  Stu &R) const
    {
        return a <= R.a;
    }
    bool operator == (const  Stu &R) const
    {
        return a == R.a;
    }
    bool operator != (const  Stu &R) const
    {
        return a != R.a;
    }

};


int main()
{
    Stu s1(10);
    Stu s2(100);
    cout << (s1>s2) << endl;
    cout << (s1>=s2) << endl;
    cout << (s1<=s2) << endl;
    cout << (s1<s2) << endl;
    cout << (s1==s2) << endl;
    cout << (s1!=s2) << endl;
    return 0;
}

ck钉钉钉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
匿名对象
Ring
05-29 249
   （1）匿名就是没有名字, 匿名对象就是没有名字的对象    （2）有名字的对象       只要用一个指针保存了某个对象的地址, 我们就可以称这个指针为某个对象       //p为Person对象       Person *p =[Person new];   （3）没有名字的对象       无论有没有名字, 只要调用new方法都会返回对象的地址       每次new都会新开辟一块存...
Day007(关键字、匿名对象、内部类、权限、类作为参数和返回值进行参数传递)
MagicStarts的博客
04-16 383
文章目录基本内容final关键字定义静态常量匿名对象匿名对象：格式如下：匿名对象的使用场景：匿名对象的内存分析：注意事项内部类什么是内部类：匿名内部类定义方式权限（四种访问修饰符）类作为参数传递和返回值类作为参数进行传递：类作为返回值进行传递 基本内容 final关键字 匿名对象 内部类 四种访问修饰符 类和接口作为参数和返回值 final关键字 修饰变量: 被他修饰的变量不可改变。一旦赋了...
Java匿名对象和实际对象作为参数传参
weixin_38367817的博客
03-30 1038
匿名对象用作参数和返回值
weixin_44599578的博客
03-04 385
匿名对象用作参数和返回值 package demo02; import java.util.Scanner; public class Demo02Anonymous { public static void main(String[] args) { //普通使用方式 // Scanner sc = new Scanner(System.in); ...
C++ day05
Amo-wintercs的博客
04-13 137
一、什么是继承 ​ 1、当遇到问题时，先查看现有的类能否解决一部分问题，如果有则继承该类，在此类的基础上进行扩展来解决问题。 ​ 可以缩短解决问题的时间（代码复用） ​ 2、当遇到复杂问题时，可以把复杂问题分解成若干个小问题，然后为每个问题设计一个类进行解决，最终通过继承语法 ​ 把这些类汇总在一个类中，达到解决问题的目的。这种处理方式可以让多人完成，以此来降低解决问题的难度。 二、基础的语法 ​ 1、继承表 class Test:继承表[继承方式 父类] { 成员变量； public: 成员
C++day3
2201_76056957的博客
01-10 235
C++day3
1.30 C++ day4
01-30
1.30 C++ day4
2.19 C++ day7
02-19
2.19 C++ day7
2.18 C++ day6
02-18
2.18 C++ day6
1.26 C++ day3
01-26
1.26 C++ day3
1.25 C++ day2
01-25
1.25 C++ day2
匿名对象作为方法的参数
追梦的女孩博客
07-12 844
package cn.ly.Day.seven.twelve; import java.util.Scanner; public class Demo05Anonymoous { public static void main(String[] args) { //普通使用方式 // Scanner sc=new Scanner(System.in); // int num=sc.nextInt(); //匿名对象的方式
C++ 继承篇
2301_79201049的博客
07-18 675
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 174
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 368
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C++ 红黑树
最新发布
wxk2227814847的博客
07-22 640
在之前的文章中，我们介绍了 C++ 标准库中的 map 和 set 容器的使用，以及 AVL 树的实现。尽管 AVL 树在平衡性方面表现优异，但在插入和删除操作频繁的应用中，红黑树（Red-Black Tree）由于其较少的旋转操作次数，往往能提供更优的性能。本篇博客将详细介绍红黑树的概念、性质、节点定义、结构、插入与删除操作、性能、迭代器设计，并展示基于红黑树的模拟实现代码及其在 map 容器中的应用。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 8980
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ck钉钉钉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值