c++入门

March 17, 2022
C++ Primer Plus（第 6 版）中文版 by Stephen Prata (z-lib.org).pdf
C++ Primer Plus（第 6 版）中文版 by Stephen Prata (z-lib.org).epub
cpp
#include <iostream>

using namespace std;
class Box
{
public:
    double data;

private:
    int *ptr;

public:
    friend void console_log(Box box); // 友元函数，可以访问私有成员，不是类的成员。友元函数实现无需friend关键字
    friend Box operator*(int num, const Box &box);
    void setData(double d);
    // 成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。
    // 在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。
    // 成员函数定义了就必须要实现，只能实现一次，如果类内部实现了就不能在外部实现了
    inline double getData() const
    { // 后面的 const 关键字表示这个函数不能修改类的数据成员
        return data;
    }
    virtual string whatABoxItIs(); // 虚函数： virtual 修饰符修饰的方法可以由子类实现，否则子类实现的方法不会被绑定，仍绑定到基类方法
    // virtual bool isBoxFull() = 0; // 纯虚函数：声明了此方法（不能定义）的类为抽象类，无法实例化
    static void sayHello() // 静态函数
    {
        cout << "hello, I am a box" << endl;
    }
    Box operator+(const Box &another)
    { // 重载 + 运算符，用于把两个 Box 对象相加
        Box box(0);
        // this是一个指向当前对象的指针
        box.data = this->data + another.data;
        return box;
    }
    Box(double d);       // 构造函数
    Box(const Box &obj); // 拷贝构造函数
    ~Box()               // 析构函数
    {
        delete ptr; // 删除指针，释放内存
        cout << "a box was destroyed" << endl;
    }
};

Box::Box(double d = 1.0) : data(d)
{
    // 此语法等同于 data = d;
    // 多个参数用逗号分隔
    ptr = new int(233);
    cout << "a box was created" << endl;
}

Box::Box(const Box &obj) // 拷贝构造函数
{
    // 隐含this
    ptr = new int;
    ptr = obj.ptr; // 拷贝值
    cout << "a box was created by copy" << endl;
}

void Box::setData(double d)
{
    // 在外部定义函数
    cout << "previous data is " << this->getData() << endl; // this 是地址 Box*
    data = d;
    cout << "data was set to " << data << endl;
}

string Box::whatABoxItIs()
{
    // 返回string而不是char*
    return "Prototype Box";
}

// 友元函数
void console_log(Box box)
{
    printf("friend: data in the box %.2lf\n", box.data);
    printf("friend: ptr in the box %.2lf\n", box.ptr);
}

Box operator*(int num, const Box &box)
{ // Box的友元
    Box newBox(num * box.data);
    return newBox;
}
ostream &operator<<(ostream &os, const Box &box)
{ // 重载<<运算符，这里没有声明为友元
    os << "overload << " << box.getData() << endl;
    return os;
}

// class SmallBox : public/private/protected[, access-specifier base-class [, ...]] Box {};
/*
公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
*/

namespace namespace_name
{
    int number = 123;
    void hello_world()
    {
        cout << "Hello, world!" << endl;
    }
    namespace namespace_innner
    {
        float secret_number = 22.0 / 7;
    }
}

void showNumber()
{
    namespace_name::hello_world();
    cout << namespace_name::number << endl;
    cout << namespace_name::namespace_innner::secret_number << endl;
}

// 泛型
template <typename T, typename U>
T addAndBecomeTheFirstType(T const a, U const b)
{
    return (T)(a + b);
}

int number = 222;

int _main()
{
    // Box box;   // 拷贝初始化，调用拷贝构造函数
    Box box(23.4); // 直接初始化，调用构造函数
    Box::sayHello();
    box.setData(10.0);
    cout << box << endl; // 10
    // console_log(box);
    cout << "data in the box " << box.getData() << endl;          // 10
    cout << "data in the newBox " << (3 * box).getData() << endl; // 30
    showNumber();
    cout << "1 + 1.1 = " << addAndBecomeTheFirstType(1, 1.1) << endl;
    cout << "1.1 + 1 = " << addAndBecomeTheFirstType(1.1, 1) << endl;
    cout << ::number << endl; // 访问全局变量
    return 0;
}
←Back to home
This work is licensed under CC BY-NC-SA 4.0