【C++】类和对象——Lesson1

于 2024-07-29 17:17:28 发布
阅读量734 收藏 31
点赞数 55
分类专栏： C++ 文章标签： c++ java android
小羊在奋斗
本文链接：https://blog.csdn.net/2301_78843337/article/details/140724990
版权

Hi~！这里是奋斗的小羊，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
💥💥个人主页：奋斗的小羊
💥💥所属专栏：C++

🚀本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为记录我的学习过程及理解。文笔、排版拙劣，望见谅。

目录

1、类的定义

C语言结构体中只能定义变量，C++中结构体内不仅可以定义变量还可以定义函数。

1.1类定义格式

class ClassName
{
	//类体：成员函数和成员变量
};
  • class为定义类的关键字，ClassName为类的名字，{ }中为类的主体
  • 类中的变量称为类的属性或成员变量，类中的函数称为类的方法或成员函数
  • C++中struct也可以定义类，C++兼容C中struct的用法，同时也升级struct成了类，一般情况下还是常用class定义类
  • 定义在类里面的成员函数默认为inline
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	//为了区分成员变量，一般习惯
	//给成员变量加一个标识
	int _year;
	int _month;
	int _day;
};

//不再需要typedef，ListNode就可以代表类型
struct ListNode
{
	int val;
	ListNode* next;
};
  • 类的两种定义方式：声明和定义全部放在类体中 / 类声明放在.h文件中，成员函数定义在.cpp文件中，成员函数名前需要加类名

1.2访问限定符

  • C++一种实现封装的方式，用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将接口（函数）提供给外部的用户使用

在这里插入图片描述

  • public修饰的成员在类外可以直接被访问，protected和private修饰的成员在类外不能直接被访问
  • 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止
  • class定义成员没有被访问限定符修饰时默认private，struct默认为public

1.3类域

  • 类定义了一个新的作用域，类的所有成员都在类的作用域中，在类外定义成员时，需要使用::作用域操作符指明成员属于哪个类域
  • 类域影响的是编译的查找规则，编译器默认只会在局部和全局查找，只有指定类域才会到类域中区查找

2、实例化

2.1什么是实例化

  • 用类类型在物理内存中创建对象的过程，称为类实例化出对象
  • 类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时才会分配空间
  • 类和对象是一对多的关系，类就像设计图一样，不能存储数据
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	//这里只是声明，没有开空间
	int _year;
	int _month;
	int _day;
};

2.2对象大小

类实例化出的每个对象，都有独立的数据空间，每个对象都有各自独立的成员变量存储各自的数据，那成员函数是否被存储呢？
如果存储的话要存函数指针，但是函数指针不会变，也就是说每个对象中的函数指针都是一样的，如果类实例化很多对象成员函数指针就要被重复存储很多次，有点浪费。
其实函数指针是不需要存储的，函数指针是一个地址，编译器在编译链接时就找到函数的地址，不是在运行时找。

类实例化出对象中只存储成员变量，C++规定类实例化的对象也要遵从内存对齐的规则。

class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};

class B
{
public:
	void Print()
	{
		//
	}
};

class C
{};

int main()
{
	A a;
	B b;
	C c;
	cout << sizeof(a) << endl;
	cout << sizeof(b) << endl;
	cout << sizeof(c) << endl;
	return 0;
}

请添加图片描述

对象b和c没有成员变量，但大小还是1，给1字节是为了占位标识对象存在。

2.3 this指针

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _ch << endl;
	}
private:
    int _year;
	int _month;
	int _day;
	char _ch;
	int _i;
}
int main()
{
	Date d1;
	Date d2;
	
	d1.Init(2024, 7, 27);
	d1.Print();

	d2.Init(2004, 11, 7);
	d2.Print();
	
	return 0;
}

Date类中有Init和Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？

  • 编译器编译后，类的成员函数默认都会在形参的第一个位置增加一个当前类型的指针，叫做this指针void Init(Date* const this, int year, int month, int day)
  • 类的成员函数中访问成员变量本质都是通过this指针访问的，C++规定不能在实参和形参的位置显示的写this指针（编译时编译器会处理），但是可以在函数体内显示使用this指针
  • this指针不能被修改，指向的内容可以修改
  • this指针存在内存中的栈区（形参）

也就是说上面的代码本质是下面这样的，但不能这样写：

class Date
{
public:
	void Init(Date* const this, int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print(Date* const this)
	{
		cout << this->_ch << endl;
	}
private:
    int _year;
	int _month;
	int _day;
	char _ch;
	int _i;
}
int main()
{
	Date d1;
	Date d2;
	
	d1.Init(&d1, 2024, 7, 27);
	d1.Print(&d1);

	d2.Init(&d2, 2004, 11, 7);
	d2.Print(&d2);
	
	return 0;
}

| 例一：

下面程序编译运行结果是什么？

#include <iostream>
using namespace std;

class A
{
public:
	void Print()
	{
		cout << "A::Print" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

p->Print();这句代码并没有对指针解引用，->这里是成员访问操作符，p是对象指针，值为nullptr，就像下面这样将对象地址传过去由this指针接收，因为p本身就是对象地址所以不用再取地址

Date d1;
d1.Print(&d1);

请添加图片描述

底层汇编代码是这样的：

在这里插入图片描述

上面程序编译运行结果是：正常运行

在这里插入图片描述

| 例二：

下面程序编译运行结果是什么？

#include <iostream>
using namespace std;

class A
{
public:
	void Print()
	{
		cout << _a << endl;
		cout << "A::Print" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

这个题的运行结果是：运行崩溃

和例一基本一致，运行崩溃的原因是：cout << _a << endl;，因为例一说了this指针为空指针，cout << this->_a << endl;对空指针解引用了。

3、C++和C语言实现Stack对比

面向对象三大特性：封装、继承、多态，通过下面的对比我们可以初步了解封装。

C语言实现Stack:

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 满了， 扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d\n", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}

C++实现Stack：

#include <iostream>
#include <assert.h>
using namespace std;

typedef int STDataType;

class Stack
{
public:
	// 成员函数
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
}
	void Pop()
	{
		assert(_top > 0);
		--_top;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	// 成员变量
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();
	return 0;
}
  • C++中数据和函数都放到了类里面，通过访问限定符进行了限制，不能再随意通过对象直接修改数据，这是C++封装的一种体现，这是最重要的变化。这里分装的本质是一种更严格规范的管理，避免乱访问修改的问题
  • C++中有一些相对方便的语法，比如Init 给缺省参数会方便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，使用类型也不再需要typedef重定义类名

4、类的默认成员函数

默认成员函数就是用户没有显示实现，编译器会自动生成的成员函数称为默认成员函数。
一个类，我们不写的情况下编译器会默认生成以下6个成员函数，默认成员函数很重要，也比较复杂，我们要从两个方面去学习。

  1. 我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求
  2. 编译器默认生成的函数不满意我们的需求，我们如何自己实现？

在这里插入图片描述

4.1构造函数

构造函数是特殊的成员数，需要注意的是，构造函数虽然名叫构造，但构造函数的主要任务并不是开空间创建对象，而是对象实例化时初始化对象。
我们常用的局部对象是栈帧创建时空间就开好了， 构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代了Init。

构造函数的特点：

  1. 函数名和类名相同
  2. 无返回值（返回值啥都不需要给，也不需要写void）
  3. 对象实例化时系统会自动调用对应的构造函数
  4. 构造函数可以重载
  5. 如果类中没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成
  6. 无参构造函数、全缺省构造函数、我们不写构造函数时编译器默认生成的构造函数，都叫默认构造函数， 但是这三个函数有且只有一个存在，不能同时存在，无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义
  7. 不传实参就可以调用的构造就叫默认构造
#include <iostream>
using namespace std;

class Date
{
public:
	// 1.⽆参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数
	/*Date(int year = 1, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}*/
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
	Date d1; // 调⽤默认构造函数
	Date d2(2025, 1, 1); // 调⽤带参的构造函数
	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
	// 区分这⾥是函数声明还是实例化对象
	// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
	Date d3();
	d1.Print();
	d2.Print();
	return 0;
}
  1. 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

大多数情况下，构造函数都需要我们自己写，应写尽写

4.2析构函数

析构函数和构造函数功能相反， 析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，不需要我们管；C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。
析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

  1. 析构函数名是在类名前加上字符~
  2. 无参数无返回值（和构造类似，也不需要加void）
  3. 一个类只能有一个析构函数，若未显示定义，系统会自动生成默认的析构函数
  4. 对象生命周期结束时，系统会自动调用析构函数
  5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用它的析构函数
  6. 我们显示写析构函数，对于自定义类型成员也会调用它的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数
  7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄露，如Stack
  8. 一个局部域的多个对象，C++规定后定义的先析构
#include<iostream>
using namespace std;
typedef int STDataType;

class Stack
{
public:
	//默认构造函数
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
	
	// 显⽰写析构，也会⾃动调⽤Stack的析构
	/*~MyQueue()
	{}*/

private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}

析构函数的意义主要在于相较于C语言我们不需要再写Init和Destroy，方便了很多。

4.3拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一个特殊的构造函数。

拷贝构造的特点：

  1. 拷贝构造函数是构造函数的一个重载
  2. 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用（如果要传值传参，则会调用拷贝构造，如果拷贝构造函数第一个参数不是引用而是传值传参，而传值传参又要调用拷贝构造，无限递归）
#include <iostream>
using namespace std;

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

	//加上const保护被拷贝对象不被改变
	//传引用一般都要加const
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

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

int main()
{
	Date d1(2024, 7, 29);
	d1.Print();

	//拷贝构造
	Date d2(d1);
	//Date d2(&d2, d1);
	d2.Print();

	return 0;
}

  1. C++规定自定义类型对象进行拷贝行为（传值传参）必须调用拷贝构造，所自定义类型传值传参和传值返回都要调用拷贝构造完成
    （所以对于自定义类型来说，不建议使用传值传参，传引用传参可以减少拷贝）

  2. 若未显示定义拷贝构造，编译器会自动生成拷贝构造函数，自动生成的拷贝构造对内置类型成员变量（拷贝构造对内置类型也处理）会完成值拷贝 / 浅拷贝（一个字节一个字节的拷贝），对自定义类型成员变量会调用它的拷贝构造

也就是说即使我们不显示的写拷贝构造函数，编译器自动生成的拷贝构造也会将d1拷贝给d2：

请添加图片描述

既然拷贝构造对内置类型和自定义类型都会用默认生成的拷贝构造完成拷贝，那我们还需要自己写拷贝构造吗？
肯定还是需要我们自己动手写的，如果用默认生成的拷贝构造完成对自定义类型的拷贝，会出现下面这种结果：

在这里插入图片描述

  1. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝 / 浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝）。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。如果一个类显示实现了析构并释放资源，那么它就需要显示写拷贝构造，否则不需要。
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

typedef int STDataType;

class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc fail");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			STDataType* tmp = (STDataType*)realloc(_a, sizeof(STDataType) * 2 * _capacity);
			if (nullptr == tmp)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			tmp = nullptr;
			_capacity *= 2;
		}
		_a[_top] = x;
		_top++;
	}

	Stack(const Stack& st)
	{
		//需要对_a指向资源创建同样大小的资源再拷贝值
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc fail");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	int _top;
	int _capacity;
};

//两个栈实现队列
class MyQueue
{
public:
	//...
private:
	Stack pushst;
	Stack popst;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);

	//如果我们不显示实现拷贝构造，则编译器自动生成的拷贝构造会完成浅拷贝
	//会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃

	//下面这两种实现的效果一样
	//Stack st2(st1);
	Stack st2 = st1;

	MyQueue mq1;
	//MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
	//的拷⻉
	//只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
	MyQueue mq2 = mq1;

	return 0;
}
  1. 传值返回会产生一个临时对象调用拷贝构造，传值引用返回返回的是返回对象的别名（引用），没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似野指针。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回
小羊在奋斗
关注
  • 55
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 46
    评论
专栏目录
C语言刷题——lesson12
fh_1998的博客
05-16 706
1. BC130-小乐乐查找数字 题目描述 给定n个整数和一个整数x，小乐乐想从n个整数中判断x出现几次，请编程帮他实现。 输入描述: 共3行 第一行，一个整数，表示n（1 <= n <= 100）。 第二行，共输入n个整数，两个整数之间用空格分隔。 第三行，输入一个整数，表示要查找的整数x。 输出描述: 一行，表示整数x出现的次数。 示例1 输入 5 1 1 2 1 3 1 输出 3 参考代码： #include <stdio.h> int main() { int
Visual_C++MFC之Lesson11
12-06
在本节"Visual C++ MFC之Lesson11"中，主要探讨了MFC应用程序中图形的保存和重绘问题，以及Windows图形处理中的坐标空间和转换机制。首先，我们来看一下如何解决图形对象在内存管理上的问题。 在事件处理函数`...
C++零基础（03）——类和对象
jiabin12230的博客
10-02 218
Lesson 03 类和对象一、 类的定义1. 定义类2. 定义对象二、 访问成员三、 成员方法总结 C++是面向对象的编程，类和对象是面向对象编程中两个最基础也是最重要的概念。 一、 类的定义 类用来描述一个对象（具体的事物）的组成，类包含属性和方法。 实际上C++中的类和C语言中的结构体有很多相似之处。 1. 定义类 class 类名 { 访问权限： 成员 }; 例子： 定义一个盒...
cpp初阶——Lesson03 类与对象（中）
VegetableGirl的博客
12-14 193
Lesson 03类与对象（中） 【本节目标】 1. 类的6个默认成员函数 2. 构造函数 3. 析构函数 4. 拷贝构造函数 5. 赋值操作符重载 6. 默认拷贝构造与赋值运算符重载的问题 7.const成员函数 8.取地址及const取地址操作符重载 1. 类的6个默认成员函数 如果一个类是空类，那它也有6个默认的成员函数。 2.构造函数 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。 2.2
[c++]——类和对象（上篇）
lucky52529的博客
02-23 171
lesson02—类和对象上篇 1.类和对象的初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 可以粗劣的将类理解为一张设计图，而通过这张设计图设计出的建筑就可以称为对象。 struct与class的区别： 解答：C++需要兼容C语言，所以C++中struct可...
孙鑫C++课程笔记2——创建类
weixin_43950839的博客
03-24 177
Lesson 2 一、结构体与类型的区别： 与C语言不同的是，在C++中的结构体允许拥有函数成员，这和类有很大的相似性，二者的主要差别在于成员的访问权限上： *缺省状态下，结构体的成员一律默认为是Public的，可以在外部访问，当然也可以将这些成员声明成Private的。 *缺省状态下，类的成员一律默认为是Private的。 二、父类与子类的成员访问规则： 三、虚函数的概念 声明方式：在函数头前面...
[c++]——类和对象（下篇）
lucky52529的博客
02-23 132
lesson04—类和对象（下篇） 1. 再谈构造函数 2.C++11 的成员初始化新玩法。 3. static成员 4. 友元 5. 内部类 1.再谈构造函数 1.1初始化列表 初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个&amp;amp;amp;amp;amp;quot;成员变量&amp;amp;amp;amp;amp;quot;后面跟一个放在括 号中的初始值或表达式。 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次) 类中
Lesson09_类和对象
weixin_44120423的博客
06-05 373
Lesson11_类和对象 面向过程和面向对象 ​ 面向过程(Procedure Oriented)和面向对象(Object Oriented,OO)都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。早期先有面向过程思想，随着软件规模的扩大，问题复杂性的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方式。两者都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向对象分析(OOA)、面向对象设计(OOD)和面向对象编程(OOP)。C语
数据结构与算法（Python）——Lesson1
weixin_43172869的博客
04-12 181
算法是计算机处理信息的本质，因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。一般地，当算法在处理信息时，会从输入设备或数据的存储地址读取数据，把结果写入输出设备或某个存储地址供以后再调用。 算法是独立存在的一种解决问题的方法和思想。 对于算法而言，实现的语言并不重要，重要的是思想。 算法可以有不同的语言描述实现版本（如C描述、C++描述、Python描述等），我们现在是在用Python语言进行描述实现。 算法的五大特性 输入: 算法具有0个或多个输入 输出: 算法至少有
Lesson1：走进C++的殿堂
Aspect of Twilight的博客
01-25 854
照片上的这位老人便是C++之父——本贾尼·斯特劳斯特卢普（Bjarne Stroustrup）。C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP（object oriented programming，面向对象）思想，支持面向对象的程序设计语言应运而生。
Lesson1.rar_Windows编程_Visual_C++_
08-12
本课程“Lesson1.rar”聚焦于Windows编程的基础，特别是C++中的核心概念——指针。指针是C++语言的一个关键特性，理解并熟练运用指针对于任何C++程序员来说都是至关重要的。 首先，我们需要理解指针的本质。指针是...
NEHE_Lesson.rar_opengl lesson
09-14
在这个“NEHE_Lesson.rar”压缩包中，你将找到一系列关于OpenGL编程的教程和实例，它们都是基于Visual C++（VC++）编写的。这些教程涵盖了从基本的窗口设置、颜色填充到复杂的纹理映射、光照模型等主题。以下是这个...
Visual_C++MFC之Lesson10创建兼容DC
12-06
在Visual C++ MFC开发中， Lesson10主要讲解了如何创建兼容设备上下文（Device Context，DC）来实现窗口中的图像绘制。设备上下文是Windows图形设备接口（GDI）中一个重要的概念，它是系统与图形设备进行交互的抽象...
lesson-7
03-31
理解类、对象、继承、封装和多态等概念，对于编写可维护、可扩展的代码至关重要。 3. **数据库管理**：我们可能还会接触到关系型数据库的基本原理，如SQL语言，用于查询、插入、更新和删除数据。理解数据库设计模式...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1234
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 683
C++ primer plus 第16章string 类和标准模板库, 关联容器。
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1141
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 283
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
评论 46
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值