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;

	}
}