C++面向对象知识大全

已于 2024-03-22 17:43:57 修改
阅读量805 收藏 8
点赞数 15
文章标签： c++ 开发语言
于 2024-03-22 16:56:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengkui198513/article/details/136933590
版权

1 类是如何存储的。变量和成员函数我们先看一段代码

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public:
	void print()
	{
		cout << "A" << endl;
	}
private:
	int _a;
};

int main()
{
	A a;
	cout << sizeof(a) << endl;
}

结果为4。说明类要么是存了成员变量要么是存了成员函数。具体是哪种呢？
下面有三种假想
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我们用代码来验证一下。

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public:
	void print()
	{
		cout << "A" << endl;
	}
private:
	int _a;
};

class B
{
public:
	void print()
	{
		cout << "A" << endl;
	}

};
class C
{

private:
	int _a;
};


int main()
{
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;
}

在这里插入图片描述
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
那既然没有存函数，连一个指向函数列表的地址都没有，对象是怎么知道去哪调用函数的。
类对象的内存布局
当你定义一个类时，类的每个实例（对象）在内存中占用一定的空间。这块空间用于存储对象的状态，即其成员变量。如果类中定义了成员函数，这些函数并不存储在每个对象的内存空间中。相反，每个成员函数只有一份代码实体，位于程序的代码段，而所有对象共享这些代码。这意味着成员函数不会影响对象的大小。

this 指针和成员函数调用
当你调用一个对象的非静态成员函数时，对象的地址被隐式地传递给函数。这个地址在成员函数内部被称为this指针。this指针是成员函数的隐式参数，指向调用该函数的对象。因此，成员函数可以访问和修改调用它的对象的成员变量。

具体步骤如下所示：
1 确定函数地址：编译器根据对象的类型和调用的成员函数确定函数的具体地址。
2 传递this指针：编译器生成代码，将对象的地址作为隐式参数（this指针）传递给成员函数。对于成员函数的内部来说，this指针就是一个指向当前对象的指针，允许函数访问对象的成员变量和其他成员函数。
3 代码执行：成员函数使用this指针访问和操作对象的状态。

类和对象的6个默认成员函数

  1. 类的6个默认成员函数
  2. 构造函数
  3. 析构函数
  4. 拷贝构造函数
  5. 赋值运算符重载
  6. const成员函数
  7. 取地址及const取地址操作符重载

在这里插入图片描述
**构造函数的知识：**如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。这里的构造不是简单的有参构造和无参构造。连拷贝构造也算。

#define  _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class A
{
public:
	void print()
	{
		cout << "A" << endl;
	}
private:
	int _a;
};

class B
{
public:
	void print()
	{
		cout << "A" << endl;
	}

};
class C
{

private:
	int _a;
};

class Date
{
public:
	Date(int year,int month,int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//cout << sizeof(A) << endl;
	//cout << sizeof(B) << endl;
	//cout << sizeof(C) << endl;
	Date d(2024, 3, 22);
	d.Print();
}

更复杂的情况

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

在这里插入图片描述
发现会调用默认的构造函数。

析构函数

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

对于自定义类型，同样也会调用自定义类型的析构函数。我们这里没有写Date类的析构函数，然但是却可以调用time的析构函数。自动创建的
在这里插入图片描述
什么时候要写析构函数，什么时候不写呢？
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

这是一段申请了资源的代码，需要写你的析构函数。

#include <iostream>

class ResourceHolder {
public:
    // 构造函数申请资源
    ResourceHolder(int size) : _size(size), _data(new int[size]) {
        std::cout << "Resource allocated with size " << _size << std::endl;
    }

    // 析构函数释放资源
    ~ResourceHolder() {
        delete[] _data;
        std::cout << "Resource deallocated" << std::endl;
    }

private:
    int _size;
    int* _data;
};

int main() {
    // 创建一个ResourceHolder对象，该对象会申请动态内存资源
    ResourceHolder holder(10);

    // 在这里，可以使用holder对象来操作动态内存资源

    // 当main函数结束时，holder对象会被销毁，析构函数会被调用，动态内存资源会被释放
    return 0;
}

拷贝构造函数
在这里插入图片描述
拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 错误写法：编译报错，会引发无穷递归
	//Date(const Date d)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

在这里插入图片描述
如果没有显示定义
编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
 Time()
 {
 _hour = 1;
 _minute = 1;
 _second = 1;
  }
 Time(const Time& t)
 {
 _hour = t._hour;
 _minute = t._minute;
 _second = t._second;
 cout << "Time::Time(const Time&)" << endl;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d1;
    
    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
构造函数
 Date d2(d1);
 return 0;
}

什么时候要自己写拷贝构造函数
这里有一个例子，

typedef int DataType;
class Stack
{
public:
	 Stack(size_t capacity = 10)
	 {
	 _array = (DataType*)malloc(capacity * sizeof(DataType));
	 if (nullptr == _array)
	 {
	 perror("malloc申请空间失败");
	 return;
 }
	  _size = 0;
	 _capacity = capacity;
 }
 void Push(const DataType& data)
 {
	 // CheckCapacity();
	 _array[_size] = data;
	 _size++;
 }
 ~Stack()
 {
	 if (_array)
	 {
		 free(_array);
		 _array = nullptr;
		 _capacity = 0;
		 _size = 0;
	 }
 }
private:
	 DataType *_array;
	 size_t _size;
	 size_t _capacity;
};
int main()
{
	 Stack s1;
	 s1.Push(1);
	 s1.Push(2);
	 s1.Push(3);
	 s1.Push(4);
	 Stack s2(s1);
	 return 0;
}

所以这种就不能用默认的拷贝构造，并且析构函数会析构两次这个地方，造成错误。
在这里插入图片描述
在这里插入图片描述

5. 拷贝构造函数典型调用场景：
使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

Date Test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d(2024, 3, 22);
	Test(d);
	return 0;
}

我们看看一共调用了多少次拷贝构造
在这里插入图片描述

在这里插入图片描述
当我们用引用的时候

Date Test(Date& d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d(2024, 3, 22);
	Test(d);
	return 0;
}

就少了一次拷贝
在这里插入图片描述
5.赋值运算符重载
5.1 运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator后面接需要重载的运算符符号。函数原型：返回值类型 operator操作符(参数列表)

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

. :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。*

同样，我们还是以Date类为例子。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	//d1==d2
	bool operator==(const Date& d)
	{
		return this->_year == d._year &&
			this->_month == d._month &&
			this->_day == d._day;
			
	}
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 3, 22);
	Date d2(2024, 3, 22);
	cout << (d1 == d2) << endl;
}

这是一种写法，另外一种（这里需要利用友元函数的思想）

class Date
{
	friend bool operator==(const Date& d1, const Date& d2);
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	//d1==d2
	//bool operator==(const Date& d)
	//{
	//	return this->_year == d._year &&
	//		this->_month == d._month &&
	//		this->_day == d._day;
	//		
	//}
private:
	int _year;
	int _month;
	int _day;
};

bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}
int main()
{
	Date d1(2024, 3, 22);
	Date d2(2024, 3, 22);
	cout << (d1 == d2) << endl;
}

5.2 赋值运算符重载
1. 赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}

		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	int _year;
	int _month;
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}```

!赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值
运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

同理，
编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

```cpp
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2;
	s2 = s1;
	return 0;
}

原理和拷贝构造类似
在这里插入图片描述
运算符重载之前置++，后置++

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
		// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
		//       而temp是临时对象，因此只能以值的方式返回，不能返回引用
		Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}
private:
	int _year;
	int _month;
	int _day;
};

const成员
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

在这里插入图片描述
使用场景是这样的，就比如说我一个打印函数，我知道不会对里面的值进行修改，但是编译器不知道。

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	//void Print() const
	//{
	//	cout << "Print()const" << endl;
	//	cout << "year:" << _year << endl;
	//	cout << "month:" << _month << endl;
	//	cout << "day:" << _day << endl << endl;
	//}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
void Test()
{
	//Date d1(2022, 1, 13);
	//d1.Print();
	const Date d2(2022, 1, 13);
	d2.Print();
}

这样的一个代码。
在这里插入图片描述
解决办法

	void Print() const
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}

**请思考下面的几个问题：

  1. const对象可以调用非const成员函数吗？ 否
  2. 非const对象可以调用const成员函数吗？ 是
  3. const成员函数内可以调用其它的非const成员函数吗？否
  4. 非const成员函数内可以调用其它的const成员函数吗？可以**

8.取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};```

**构造函数深入理解**
初始化列表

```cpp
class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)

class A
{
public:
	A()
	{

	}
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:
	B(A a, int ref)
		:_aobj(a)
		,int_n(10)
		,_ref(ref)
	{}
		
private:
	A _aobj;
	int& _ref;
	const int int_n;

};

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关这个申明次序就是指private下的顺序。！！！！int 变量未初始化就是随机值。

测试题目

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}

这里的输出结果为1 ，随机值。

1.3 explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

首先我们要理解什么是隐私类型转换
在这里插入图片描述
证明这个问题：
在这里插入图片描述

我们知道临时变量具有常性，就是不可改变。

int main()
{
	int i = 2;
	const double& d = i;
}

这样就没有问题了。
那这个关键字的作用呢

class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
	Date(int year)
		:_year(year)
	{}
	/*
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
   有类型转换作用
	// explicit修饰构造函数，禁止类型转换
	explicit Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}
	*/
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

当我们加上这个关键字之后
在这里插入图片描述

2. static成员
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
面试题

class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
	static int GetACount() { return _scount; }
private:
	static int _scount;
};

int A::_scount = 0;
void TestA()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}

输出 0 3
特性：

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

问题？
【问题】
6. 静态成员函数可以调用非静态成员函数吗？不可以
7. 非静态成员函数可以调用类的静态成员函数？可以

静态成员函数不能直接调用非静态成员函数。这是因为静态成员函数属于类本身，而不是类的某个具体对象。非静态成员函数需要一个具体的对象实例来调用，因为它们可能会访问或修改对象的非静态成员变量。如果静态成员函数想要调用一个非静态成员函数，它需要通过某个对象实例来调用这个非静态成员函数。

非静态成员函数可以调用类的静态成员函数。静态成员函数不依赖于类的任何特定实例，它们可以被类的任何成员函数调用，无论是静态的还是非静态的。静态成员函数可以看作是全局函数，但它们在类的作用域内。

3 友元
很实用的地方
重载operator<<，然后发现没办法将operator<<重载成成员函数。**因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。**this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

错误的代码


class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d(1,2,3);
	cout << d << endl;
	return 0;
}

在这里插入图片描述
这里要用友元
（在类外外面写会造成读取不到这个成员属性，因为是private）,将这个函数作为友元

在这里插入图片描述
成功运行

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}


private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout,const Date & d)
{
	_cout << d._year << endl;
	return _cout;
}
int main()
{
	Date d(1,2,3);
	cout << d << endl;
	return 0;
}

友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

3.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递如果C是B的友元， B是A的友元，则不能说明C时A的友元。友元关系不能继承，在继承位置再给大家详细介绍。

内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。
小曾同学杀疯了
关注
  • 15
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Visual C++ 6 参考大全
11-08
本书的目的是为了帮助广大Visual C＋＋6的读者快速熟悉和掌握Microsoft Visual C＋＋6编译软件包，使具有不同编程背景的人更加精通C、C＋＋及32位的Windows编程技术。全书由六大部分即Visual C＋＋快速入门、编程基础、 C＋＋面向对象、 Windows编程基础、向导、和附录构成；下面又细分为二十七章，主要内容包括： Visual C＋＋编译器版本6、 IDE快速入门、编写、编译和调试简单程序、 Visual C＋＋高级功能、 C和 C＋＋编程、使用数据、程序控制、编写、使用函数、数组、使用指针、 C的完整 I／O． C＋＋的 I／O简介、结构、联合及其他、高级编程主题、强力编程：重要的 C和 C＋＋库、面向对象编程基础、C＋＋的类、C＋＋的完全1／O、在面向对象环境中工作、Windows编程基础、面向过程的Windows应用程序、 Microsoft基础类库入门、使用MFC的Windows应用程序、应用程序与类向导、OLE入门、ActiveX控件入门和COM与DHTML。通 过本书的学习，读者不但能快速学习和掌握Microsoft Visual C＋＋6的重要的基础知识，而且还能学会调试程序代码，编写无语法错误的程序，理解面向过程编程与面向对象编程之间的差别，并且学会开发从简单到中高级的 面向对象程序的方法。此外，全书通过实例练习来学习编程。书中提供的范例简洁、完整和无误，读者还可以对这些范例进行研究、修改和扩展，使其符合自己的需 求。全书结构清晰、合理，范例实用、丰富。本书不但是从事Microsoft Visual C＋＋6开发和应用的广大用户的重要参考书，同时也是大专院校相关专业师生的自学、教学参考用书。本书配套光盘的内容包括与本书配套的电子书，提供读者长 久保存和方便学习。另外还赠送“精通Visual C＋＋ 5．0”多媒体教学软件。
3、java面向对象编程
04-07 179
1、面向对象内存分析 栈的特点 　　　　（1）JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等） 　　　　（2）栈属于线程私有，不能实现线程间的共享！ 　　　　（3）栈的存储特性是：先进后出，后进先出。由系统自动分配，速度快！是一个连续的内存空间。 　　　　（4）栈描述的是方法执行的内存模型，每个方法被调用会创建一个栈帧（存储局部变...
【用C++面向对象的思想以及STL完成贪吃蛇游戏】
q_2474932226的博客
03-09 451
用C++面向对象的编程思想以及STL完成的贪吃蛇游戏
C++基础知识大全
热门推荐
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
c++基础课件资料大全
08-08
全面细致的介绍了 c++的基础知识 面向对象 和 基于对象的 编程模式也有介绍
Visual C++开发技术大全 明日科技 高清pdf 分卷1
10-09
全书共分31章，包括认识Visual C++，C++语言基础，C++语句控制，数组，函数，面向对象的程序设计，用户界面设计，文档与视图，菜单、工具栏和状态栏设计，通用对话框，高级控件，自制MFC控件，图形、图像处理技术，...
Visual C++开发技术大全 明日科技 高清pdf 分卷2
10-09
全书共分31章，包括认识Visual C++，C++语言基础，C++语句控制，数组，函数，面向对象的程序设计，用户界面设计，文档与视图，菜单、工具栏和状态栏设计，通用对话框，高级控件，自制MFC控件，图形、图像处理技术，...
Visual C++ 开发技术大全.part2.rar
11-01
全书共分32章，包括认识Visual C++，C++语言基础，C++语句控制，数组，函数，面向对象的程序设计，Win32 API，用户界面设计，文档与视图，菜单、工具栏和状态栏设计，通用对话框，高级控件，ActiveX控件，自制MFC...
C语言.动态内存管理
Joseit的博客
05-16 587
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
c语言操作注意事项
dropLin的博客
05-20 111
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C/C++免杀--原生态(GG)
最新发布
金灰的博客
05-20 174
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 252
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 896
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 411
一篇文章带你学会结构体的内存对齐！！超多精美配图！
c++04STL部分复习
2301_80434259的博客
05-13 183
c++基础回复
C语言星号带括号的情形
bcbobo21cn的专栏
05-11 81
C语言星号，当星号右侧是一个指针变量，星号和指针变量可看作一个整体，表示的是指针变量所指的内容；
STL--set和multiset集合
m0_75266675的博客
05-20 634
STL--set和multiset集合
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
c++ 面向对象 小游戏
04-23
C++面向对象小游戏是一种基于C++面向对象编程思想的游戏开发方式。在这种游戏中，所有的游戏元素都被抽象成对象，每个对象都有自己的属性和方法。这种开发方式可以使游戏的开发更加模块化和可维护，同时也可以提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值