c++ 对象和类

内容包括
构造函数和析构函数

类

类声明：以数据成员的方式描述了数据部分，以成员函数（方法）的方式描述公有接口。
类方法定义：描述如何实现类成员函数。
定义位于类声明中的函数都将自动称为内联函数。
c++的目标是使得使用类与使用基本的内置类型尽可能相同。
要创建类对象，可以声明类变量，也可以使用new为类对象分配存储空间，可以将对象作为函数的参数和返回值，也可以将一个对象赋给另一个。

#include <iostream>
#include <cstring>

class Stock
{
private:
    char company[30];
    int shares;
    double share_val;
    double total_val;
    void set_tot() {total_val= shares*share_val;}
public:
    Stock();
    Stock(const char * co, int n = 0, double pr = 0.0);
    ~Stock();
    void acquire(const char * co, int n, double pr);
    void buy(int num, double price);
    void update(double price);
    void show();
};

void Stock::acquire(const char * co, int n, double pr)
{
    std::strncpy(company,co,29);
    company[29] = '\0';
    if(n<0)
    {
        std::cerr << "sdfghj" << company << "hjkl" <<endl;
        shares = 0;
    }
    else
        shares = 0;
    share_val = pr;
    set_tot();
}

int main()
{
    using std::cout;
    using std::ios_base;
    Stock ht20;
    ht20.acquire("nanosmart", 20, 12.50);//直接传入字符串
    cout.setf(ios_base::fixed);
    cout.precision(2);
    ht20.show();
    return 0;

构造函数和析构函数

程序声明对象时，将自动调用构造函数。
构造函数的参数表示的不是类成员，而是赋给类成员的值。为避免这种混乱，通常的做法是在数据成员名中使用m_前缀。

Stock::Stock(const char * co, int n, double pr){}

使用构造函数
1.显示调用

Stock food = Stock("World Cabbage", 250, 1.2);

2.隐式调用

Stock garment("Furry Mason", 50, 2.3);

默认构造函数是在未提供显式的初始化值时，被用来创建对象的构造函数。如

Stock stock1;

如果提供了非默认构造函数，则在声明时必须保持和非默认构造函数一致。但是，如果要创建对象而不显式的初始化，则必须定义一个不接受任何参数的默认构造函数。
一种是

Stock(const char * co, int n = 0, double pr = 0.0);

另一种，通常给所有成员提供隐式初始值。如

Stock::Stock()
{
    std::strcpy(company, "no name");
    shares = 0;
    share_val = 0.0;
    total_val  0.0;
}

使用上述创建了默认构造函数后，便可以声明对象变量而不进行显式初始化。

Stock first;
Stock first = Stock();
Stock *prelief = new Stock;

析构函数

~Stock（）
{
}

this指针

关于this指针的一个精典回答:

当你进入一个房子后，
你可以看见桌子、椅子、地板等，
但是房子你是看不到全貌了。
对于一个类的实例来说，
你可以看到它的成员函数、成员变量，
但是实例本身呢？
this是一个指针，它时时刻刻指向你这个实例本身。
什么是this指针？
this是指向实例化对象本身时候的一个指针，里面存储的是对象本身的地址，通过该地址可以访问内部的成员函数和成员变量。
什么作用？
this作用域是在类的内部，自己声明一个类的时候，还不知道实例化对象的名字，所以用this来使用对象变量的自身。在非静态成员函数中，编译器在编译的时候加上this作为隐含形参，通过this来访问各个成员（即使你没有写上this指针）。
使用：
1)在类的非静态成员函数中返回对象的本身时候，直接用return *this(常用于操作符重载和赋值、拷贝等函数)。2)传入函数的形参与成员变量名相同时，例如：this->n = n (不能写成n=n)
ex：

class Point
{ 
    int x, y;
public:
    Point(int a, int b) { x=a; y=b;}
    Void MovePoint( int a, int b){ x+=a; y+=b;}
    Void print(){ cout<<"x="< };
void main( )
{
     Point point1( 10,10);
     point1.MovePoint(2,2);
     point1.print( );
}

1. 对象point1调用MovePoint(2,2)的时候，即将point1对象的地址传递给了this指针
2. 编译器编译后的原型应该是void MovePoint(Point *this, int a, int b)
3. 在函数体中可以写成{this->x += a; this->y += b;}
4. 也等价为point1.x += a；point1.y += b。(指针变量通过->访问成员变量(函数)，对象通过.)

对象数组

与声明标准类型数组相同

Stock mystuff[4];