c++-变量，this指针，全局函数，成员函数，自定义数组类

区分变量属于哪个对象

• c++对象管理模型初探
  • c++类对象中的成员变量和成员函数是分开存储的，c中内存四区仍然有效
  • c++编译器对普通成员函数的内部处理（隐藏this指针）
  • this指针解决函数形参和类属性相同
  • 类成员函数写const，修饰的是谁？
  • 全局函数 pk 类成员函数
  • 类成员函数返回指针 和 返回引用
• c++类对象中的成员变量和成员函数是分开存储的，c中内存四区仍然有效
• c++编译器对普通成员函数的内部处理（隐藏this指针）
• this指针解决函数形参和类属性相同
• 类成员函数写const，修饰的是谁？
• 全局函数 pk 类成员函数
• 类成员函数返回指针 和 返回引用

#define _crt_secure_no_warnings
#include <iostream>


using namespace std;

class test
{
public:
    test(int i)
    {
        mi = i;
    }

    int geti()
    {
        //this就是指向调用改成员函数方法的对象地址
        return this->mi;
        //return mi;
    }
private:
    int mi;
};

/*
struct test
{
    int mi;
};

void test_init(test *pthis, int i)
{
    pthis->mi = i;
}

int geti(struct test *pthis)
{
    return pthis->mi;
}
*/
int main(void)
{

    test t1(10);//test(&t1, 10)
    test t2(20);

    t1.geti();// geti(&t1)
    
    return 0;
}

　this指针

#define _crt_secure_no_warnings
#include <iostream>


using namespace std;

class test
{
public:
    test(int k)
    {
        this->m_k = k;
    }

    int getk()  const//成员函数尾部出现const 修饰是this指针
    {
        //this->m_k = 100; //this指针不是 const test *
        //this++;// this指针是一个常指针， test *const  
        //this->m_k = 100;
        //this = this + 1;
        return this->m_k;
    }

    //static成员函数，只能返回static成员变量
    static int s_getk()
    {
        //return m_k;
        return s_k;
    }
private:
    int m_k;
    static int s_k;
};

int test::s_k = 0;


int main(void)
{
    test t1(10); //test(&t1, 10);
    test t2(20);


    return 0;
}

全局函数和成员函数

如果想返回一个对象的本身，在成员方法中，用*this返回
}

#define _crt_secure_no_warnings
#include <iostream>


using namespace std;

class test
{
public:
    test(int a, int b)
    {
        this->a = a;
        this->b = b;
    }

    void printt()
    {
        cout << "a = " << this->a << ", b=" << this->b << endl;
    }

    int geta()
    {
        return this->a;
    }

    int getb()
    {
        return this->b;
    }

    //成员方法
    test testadd(test &another)
    {
        test temp(this->a + another.a,this->b + another.b);

        return temp;
    }

    //+= 方法
    test& testadd2(test &another)
    {
        this->a += another.a;
        this->b += another.b;

        //this===>&t1
            
        return *this;//如果想返回一个对象的本身，在成员方法中，用*this返回
    }

private:
    int a;
    int b;
};


/*
//1 在全局提供一个两个test想加的函数
test testadd(test &t1, test &t2)
{
    test temp(t1.geta() + t2.geta(), t1.getb() + t2.getb());

    return temp;
}
*/

int main(void)
{
    test t1(10, 20);
    test t2(100, 200);

    //test t3 = testadd(t1, t2);
    test t3 = t1.testadd(t2);

    t3.printt();


    //((t1 += t2) += t2 )+= t2

    //如果相对一个对象连续调用成员方法，每次都会改变对象本身，成员方法需要返回引用。
    t1.testadd2(t2).testadd2(t2);

    t1.printt();

    return 0;
}

自定义数组类

main.cpp

#define _crt_secure_no_warnings
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <fstream>
#include "myarray.h"

using namespace std;

int main(void)
{

    myarray array1(10);//开辟10元素的数组

    //赋值操作
    for (int i = 0; i < 10; i++) {
        array1.setdata(i, i + 10);
    }

    cout << "--------" << endl;

    cout << "array1:" << endl;
    for (int i = 0; i < 10; i++) {
        cout << array1.getdata(i) << " ";
    }
    cout << endl;

    myarray array2 = array1;
    cout << "array2:" << endl;
    for (int i = 0; i < array2.getlen(); i++) {
        cout << array2.getdata(i) << " ";
    }
    cout << endl;

    myarray array3;
    array3 = array1;


    cout << "array3:" << endl;
    for (int i = 0; i < array3.getlen(); i++) {
        cout << array3.getdata(i) << " ";
    }
    cout << endl;

    return 0;
}

array.h

#pragma once
#include <iostream>

using namespace std;

class myarray
{
public:
    myarray();
    myarray(int len);
    myarray(const myarray &another);
    ~myarray();

    void setdata(int index, int data);
    int getdata(int index);
    int getlen();

    void operator=(const myarray& another);
private:
    int len;
    int *space;
};

array.cpp

#include "myarray.h"


myarray::myarray()
{
    cout << "myarray()..." << endl;
    this->len = 0;
    this->space = null;
}

myarray::myarray(int len)
{
    if (len <= 0) {
        this->len = 0;
        return;
    }
    else {
        this->len = len;

        //给space开辟空间
        this->space = new int[this->len];
        cout << "myarray::myarray(int len) ..." << endl;
    }
}
myarray::myarray(const myarray &another)
{
    if (another.len >= 0) {
        this->len = another.len;

        //深拷贝
        this->space = new int[this->len];
        for (int i = 0; i < this->len; i++) {
            this->space[i] = another.space[i];
        }
        cout << "myarray::myarray(const myarray &another) ..." << endl;

    }
}
myarray::~myarray()
{
    if (this->space != null) {
        delete[]this->space;
        this->space = null;
        len = 0;
        cout << "myarray::~myarray() ..." << endl;
    }
}

void myarray::setdata(int index, int data)
{
    if (this->space != null) {
        this->space[index] = data;
    }
}
int myarray::getdata(int index)
{
    return this->space[index];
}
int myarray::getlen()
{
    return this->len;
}

void myarray::operator=(const myarray& another)
{
    if (another.len >= 0) {
        this->len = another.len;

        //深拷贝
        this->space = new int[this->len];
        for (int i = 0; i < this->len; i++) {
            this->space[i] = another.space[i];
        }
        cout << "myarray::operator=(const myarray& another) ..." << endl;

    }
}