C++工程笔记(配合SDUST OJ食用)

2023-10-23 15:40

本文主要是介绍C++工程笔记(配合SDUST OJ食用),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

使用了using namespace std; 仍然可以写std::cout

析构函数会在生命结束时自动调用

类内指针当作数组使用时需要先new分配内存

有关联的类可以加上友元 操作起来更加方便 T1779

输出构造、析构消息的题目一点内存都不能多开 否则会输出冗余信息

需要返回一个对象时可以先定义一个对象 并在类内写上无参构造函数T1829

先开空间再赋值T1784

定义在类内的数组需要先清空再使用 否则会有垃圾值T1816

注意const(只读) 与 &的使用

Eg.

设置Point对象的x坐标(第一个参数)和y坐标(第二个参数)并返回本对象:T1125

Point &setPoint(double x, double y)

    {

        a = x, b = y;

        return *this;

    }

const类型的变量在调用成员函数时要在参数名之后加上const(常对象只能调常函数)

Eg.

 const Point const_point(3, 3);

    const_point.show();

    for(int i = 0; i <= l; i++)

    {

        if(const_point.isEqual(pt[i]))

        {

            ShowPoint(const_point);

            ShowPoint(const_point.x(), const_point.y());

            ShowPoint(Point(const_point.x(), const_point.y()));

        }

bool isEqual(const Point &p)const

    {

        if(p.a == a && p.b == b)

            return true;

        else    return false;

    }

 

 

在初始化对象时尽量使用初始化列表:效率更高且可行性更高

 

&不会开辟新的空间 如果不写可能会建立新的对象

 

类如何开数组?

写一个无参函数 例如:

Line():p1(0, 0), p2(0, 0) {}

重载流运算符需要注意的点:1.返回值类型 2.参数类型 3.输入输出流 4.返回值

friend istream& operator>>(istream& is, Time& rhs)

    {

        is >> rhs.hh >> rhs.mm >> rhs.ss; //要注入具体成员

        return is;

    }

    friend ostream& operator<<(ostream& os, const Time& rhs)

    {

        if(rhs.hh < 0 || rhs.hh >= 24 || rhs.mm < 0 || rhs.mm >= 60 || rhs.ss < 0 || rhs.ss >= 60)

            os << "error!!!";

        else

            os << setw(2) << setfill('0') << rhs.hh;

        return os;

    }

前自增与后自增(减法同理):

Time& operator++()

    {

        if(!is_leagal())    {}

        else

        {

            ss ++;

            while(ss >= 60) ss -= 60, mm ++;

            while(mm >= 60) mm -= 60, hh ++;

            hh = (hh + 24) % 24;

        }

        return *this;

    }

    Time operator++(int) //这里要加int

    {

        Time t(*this);

        if(!is_leagal())    {}

        else

        {

            ss ++;

            while(ss >= 60) ss -= 60, mm ++;

            while(mm >= 60) mm -= 60, hh ++;

            hh = (hh + 24) % 24;

        }

        return t; //注意这里后自增要返回初始拷贝的对象

    }

 

在传递字符串类中的字符参数时也要记得初始化其他对象

Eg.

private:

    char* str;

    int len;

public:

    STR():str(NULL), len(0) {}

    STR(const char* _str):len(0)

    {

        for(int i = 0; _str[i] != '\0'; i++)

            len++;

        str = new char[len + 1];

        for(int i = 0; _str[i] != '\0'; i++)

            str[i] = _str[i];

        str[len] = '\0';

    }

 

在类中带指针的成员一般需要进行动态内存分配 否则容易出错

delete数组要加[]

 

 

静态成员调用一定要用const

 

在写一个类的函数类模板时,记得写上public(class默认成员为private)

 

 

在类外调用类中某一成员函数时必须为静态成员函数

如:

类外:cout<<Point::showNumber()

类内:static int showNumber() {return num2;}

否则需要实例化,即:利用类定义一个对象,然后再调用成员函数

 

T1814用子类初始化父类

Derived(const Derived& d):x_(d.x_), Base(d) {cout << "Derived = " << x_ << " is copied." << endl;}

 

 

 

多继承:先继承,后组合

 

子类对象中包含父类子对象:里氏替换原则

 

纯虚函数不能实例化(定义对象): virtual void show()const = 0;

但是可以定义它的指针

 

//虚继承

#include <iostream>

using namespace std;

class A

{

    public:

        int a;

        A(int aa):a(aa) {}

};

class B : virtual public A

{

    public:

        int b;

        B(int aa, int bb):A(aa), b(bb) {}

};

class C : virtual public A

{

    public:

        int c;

        C(int aa, int cc):A(aa), c(cc) {}

};

class D : public B, public C

{

    public:

        int d;

        D(int x, int y, int z, int r):d(r), A(x), B(-1, y), C(-10086, z) {}

};            //此处初始化无效

int main()

{

    D ddd(1, 2, 3, 4);

    cout << ddd.d << endl;

    cout << ddd.c << endl;

    cout << ddd.b << endl;          

    cout << ddd.a << endl;

    cout << ddd.A::a << endl;

    cout << ddd.B::a << endl;

    cout << ddd.C::a << endl;

    cout << ddd.D::a << endl;

    return 0;

}

最终只有一个a

 

 

// 虚函数

#include <iostream>

using namespace std;

class A

{

    public:

        int a;

        A(int aa):a(aa) {}

        virtual void show() {cout << a << endl;}

};

class B : public A

{

    public:

        int b;

        B(int aa, int bb):A(aa), b(bb) {}

        void show() {cout << a << ' ' << b << endl;}

};

class C : public A

{

    public:

        int c;

        C(int aa, int cc):A(aa), c(cc) {}

        void show() {cout << a << ' ' << c << endl;}

};

class D : public A

{

    public:

        int d;

        D(int aa, int cc):A(aa), d(cc) {}

        void show() {cout << a << ' ' << d << endl;}

};

/* 

class D : public B, public C

{

    public:

        int d;

        D(int x, int y, int z, int r):d(r), A(x), B(-1, y), C(-10086, z) {}

        

};  */

int main()

{

    A* p[5];

    B b(1, 2);

    C c(10, 20);

    D d(-1, -2);

    A a(1000000);

    C cc(77, 77);

    p[0] = &a;

    p[1] = &b;

    p[2] = &c;

    p[3] = &cc;

    p[4] = &d;

    for(int i = 0; i < 5; i ++)

        p[i]->show();

    return 0;

}

 

虚析构函数才能访问子类的虚构函数,并且能够防止内存泄漏

 

子类和父类关系是可以套很多层的:eg.

class Graphic

{

public:

    virtual void show() = 0;

};

class Shape : public Graphic

{

public:

    virtual void show() = 0;

};

class Solid : public Graphic

{

public:

    virtual void show() = 0;

};

class Square : public Shape

{

private:

    double a_;

public:

    Square(double a):a_(a) {}

    void show() {cout << "Square, side:" << a_ << ", area:" << a_ * a_ <<'.' << endl;}

};

 

Problem1680学到的:

如果数组模板类不好写 我们不妨直接使用vector

Fract& operator+=(Fract rhs)

    {

        if(cnt_ & 1) m_ = -m_;

        if(rhs.cnt_ & 1) rhs.m_ = -rhs.m_;

        int val = lcm(m_, rhs.m_);

        int x1 = val / m_, x2 = val / rhs.m_;

        z_ *= x1, rhs.z_ *= x2;

        Fract fract(z_ + rhs.z_, val);

        return *this = fract;

    }

重载+=要传引用 不方便写时可采用最后两句,先构造再赋值返回

重载流输入的过程中可以做其他事情

friend istream& operator>>(istream& is, Fract& f)

    {

        int z, m;

        is >> z >> m;

        f = Fract(z, m);

        return is;

    }

直接构造更加顺畅

重载强制类型转换

 operator double()

    {

        return (double)z_ / m_;

    }

 

 

对子类成员初始化要用子类构造函数

 

T2310在重载下标运算符时他需要有一个返回的其他类的对象 并且要传回此类的引用才能修改其自身属性

 

 

这篇关于C++工程笔记(配合SDUST OJ食用)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/268788

相关文章

c++ 类成员变量默认初始值的实现

《c++类成员变量默认初始值的实现》本文主要介绍了c++类成员变量默认初始值,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录C++类成员变量初始化c++类的变量的初始化在C++中,如果使用类成员变量时未给定其初始值,那么它将被

C++中NULL与nullptr的区别小结

《C++中NULL与nullptr的区别小结》本文介绍了C++编程中NULL与nullptr的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编... 目录C++98空值——NULLC++11空值——nullptr区别对比示例 C++98空值——NUL

C++ Log4cpp跨平台日志库的使用小结

《C++Log4cpp跨平台日志库的使用小结》Log4cpp是c++类库,本文详细介绍了C++日志库log4cpp的使用方法,及设置日志输出格式和优先级,具有一定的参考价值,感兴趣的可以了解一下... 目录一、介绍1. log4cpp的日志方式2.设置日志输出的格式3. 设置日志的输出优先级二、Window

从入门到精通C++11 <chrono> 库特性

《从入门到精通C++11<chrono>库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段(Durat

C++20管道运算符的实现示例

《C++20管道运算符的实现示例》本文简要介绍C++20管道运算符的使用与实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录标准库的管道运算符使用自己实现类似的管道运算符我们不打算介绍太多,因为它实际属于c++20最为重要的

Visual Studio 2022 编译C++20代码的图文步骤

《VisualStudio2022编译C++20代码的图文步骤》在VisualStudio中启用C++20import功能,需设置语言标准为ISOC++20,开启扫描源查找模块依赖及实验性标... 默认创建Visual Studio桌面控制台项目代码包含C++20的import方法。右键项目的属性:

c++中的set容器介绍及操作大全

《c++中的set容器介绍及操作大全》:本文主要介绍c++中的set容器介绍及操作大全,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录​​一、核心特性​​️ ​​二、基本操作​​​​1. 初始化与赋值​​​​2. 增删查操作​​​​3. 遍历方

解析C++11 static_assert及与Boost库的关联从入门到精通

《解析C++11static_assert及与Boost库的关联从入门到精通》static_assert是C++中强大的编译时验证工具,它能够在编译阶段拦截不符合预期的类型或值,增强代码的健壮性,通... 目录一、背景知识:传统断言方法的局限性1.1 assert宏1.2 #error指令1.3 第三方解决

C++11委托构造函数和继承构造函数的实现

《C++11委托构造函数和继承构造函数的实现》C++引入了委托构造函数和继承构造函数这两个重要的特性,本文主要介绍了C++11委托构造函数和继承构造函数的实现,具有一定的参考价值,感兴趣的可以了解一下... 目录引言一、委托构造函数1.1 委托构造函数的定义与作用1.2 委托构造函数的语法1.3 委托构造函

C++11作用域枚举(Scoped Enums)的实现示例

《C++11作用域枚举(ScopedEnums)的实现示例》枚举类型是一种非常实用的工具,C++11标准引入了作用域枚举,也称为强类型枚举,本文主要介绍了C++11作用域枚举(ScopedEnums... 目录一、引言二、传统枚举类型的局限性2.1 命名空间污染2.2 整型提升问题2.3 类型转换问题三、C