C++一周学习总结（2021/05/03）

最新推荐文章于 2023-03-05 15:14:47 发布
最新推荐文章于 2023-03-05 15:14:47 发布
阅读量363 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjswift/article/details/116381357
版权

1、友元

为了能访问某个类中的所有成员方法和成员数据

两种方式：

① 友元函数

在类的头文件中增加：friend 函数名(参数);

[例]有一个计算机类，需要对这个计算机的CPU进行升级

头文件：

#pragma once
#include <string>

using namespace std;

class Computer
{
public:
	Computer();

	string description();
	//定义update函数为Computer类的友元函数，可以访问类中的任何数据和方法（在public/private中任意地方都可定义）
	friend void update(Computer &computer);
private:
	string cpu;
};

实现：

#include <sstream>
#include "Computer.h"

Computer::Computer(){
	this->cpu = "i7";
}

string Computer::description(){
	stringstream ret;
	ret << "cpu:" << cpu;
	return ret.str();
}

实现CPU升级

#include <iostream>
#include "Computer.h"
#include "ComputerService.h"

void update(Computer &computer) {
	computer.cpu = "i9";
}

int main() {
	Computer computer;
	cout << computer.description() << endl;

	update(computer);

	cout << computer.description() << endl;

	return 0;
}

② 友元类

通过一个类来实现对另一个类的数据成员和成员方法进行访问或修改
[例] 实现一个计算机服务类来实现对计算机的升级，杀毒，空间清理等功能

ComputerService.h

#pragma once

class Computer;

class ComputerService
{
public:
	void update(Computer *computer);
	void clean(Computer *computer);
	void kill(Computer *computer);
};

Computer.h

#pragma once
#include <string>
#include "ComputerService.h"

using namespace std;

class Computer
{
public:
	Computer();

	string description();
private:
	string cpu;

	//可以对另一个类中的指定的成员函数声明为友元
//	friend void ComputerService::update(Computer *computer);

	friend class ComputerService;	//声明为友元类
};

ComputerService.cpp

#include <iostream>
#include "ComputerService.h"
#include "Computer.h"`

void ComputerService::update(Computer *computer)
{
	computer->cpu = "i9";
}

void ComputerService::clean(Computer * computer)
{
	std::cout << "正在清理电脑[cpu:" << computer->cpu << "]" << endl;
}

void ComputerService::kill(Computer * computer)
{
	std::cout << "正在进行电脑杀毒[cpu:" << computer->cpu << "]" << endl;
}

调用：

#include <iostream>
#include "Computer.h"
#include "ComputerService.h"

int main() {
	Computer computer;
	cout << computer.description() << endl;
	
	ComputerService service;
	service.update(&computer);
	service.clean(&computer);
	service.kill(&computer);

	cout << computer.description() << endl;

	return 0;
}

2.运算符重载

- 重载＋运算符

方式一：使用成员函数
方式二：使用友元函数

[例] 实现一斤牛肉等于两斤猪肉，一斤羊肉等于三斤猪肉，将牛肉与羊肉相加

猪肉头文件

#pragma once
#include <string>
class Pork
{
public:
	Pork(int weight = 0);
	std::string description() const;

private:
	int weight;
};

猪肉实现类：

#include <sstream>
#include "Pork.h"

Pork::Pork(int weight)
{
	this->weight = weight;
}

std::string Pork::description() const
{
	std::stringstream ret;
	ret << "猪肉的重量为:" << weight << "斤";

	return ret.str();
}

牛肉头文件

#pragma once

class Pork;
class Mutton;

class Beef
{
public:
	Beef(int weight = 0);
	//方式一: 使用成员函数来进行操作符重载
	Pork operator+(Mutton mutton);		//当前对象（牛肉）+ 羊肉，返回猪肉
	Pork operator+(Beef beef);		//当前对象（牛肉）+ 牛肉，返回猪肉

//方式二: 使用友元函数来实现操作符重载
	friend Pork operator+(const Beef &beef, const Mutton &mutton);
	friend Pork operator+(const Beef &beef1, const Beef &beef2);
private:
	int weight;
};

牛肉实现类：

#include "Beef.h"
#include "Mutton.h"
#include "Pork.h"

Beef::Beef(int weight)
{
	this->weight = weight;
}

Pork Beef::operator+(Mutton mutton)
{
	int wei = this->weight * 2 + mutton.getWeight() * 3;	//牛肉的价格是猪肉的2倍，羊肉的价格是猪肉的3倍
	return Pork(wei);	//返回猪肉
}

Pork Beef::operator+(Beef beef)
{
	int wei = (this->weight + beef.weight) * 2; 	//牛肉的价格是猪肉的2倍，羊肉的价格是猪肉的3倍
	return Pork(wei);	//返回猪肉
}

羊肉头文件

#pragma once
class Mutton
{
public:
	Mutton(int weight = 0);
	int getWeight() const;

private:
	int weight;
};

羊肉类的实现类

#include "Mutton.h"

Mutton::Mutton(int weight)
{
	this->weight = weight;
}

int Mutton::getWeight() const
{
	return this->weight;
}

main函数

#include <iostream>
#include "Beef.h"
#include "Mutton.h"
#include "Pork.h"

//友元函数来实现操作符重载
Pork operator+(const Beef &beef,const Mutton &mutton) {
	int ret = beef.weight * 2 + mutton.getWeight() * 3;
	return Pork(ret);
}

Pork operator+(const Beef &beef1, const Beef &beef2) {
	int ret = (beef1.weight + beef2.weight) * 2;
	return Pork(ret);
}

int main() {
	Beef beef(100);
	Beef beef2(160);
	Mutton mutton(100);

	std::cout << (beef + mutton).description() << std::endl;
	std::cout << beef.operator+(mutton).description() << std::endl;

	std::cout << (beef + beef).description() << std::endl;

	Pork p;
	p = beef + mutton;
	std::cout << p.description() << std::endl;

	p = beef + beef2;
	std::cout << p.description() << std::endl;
	return 0;
}

- 重载赋值运算符（=）

Boy创建boy1，boy2，boy3，把boy1的内容赋值给boy2，boy3

boy头文件：

#pragma once
#include <string>

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();

	string description();
	/*
	 返回引用类型，便于连续赋值
	 参数使用引用类型， 可以省去一次拷贝
	 参数使用const, 便于保护实参不被破坏
	*/
	Boy& operator=(const Boy &boy);

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
};

boy实现类：

#include <sstream>
#include "Boy.h"

int Boy::lastId = 0;

Boy::Boy(const char * name, int age, int salary, int darkHorse)
{
	if (!name) {	//判断name是否为空
		name = "无名";
	}
	
	this->name = new char[strlen(name)+1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;

	id = ++lastId;
}

Boy::~Boy()
{
	delete name;
}

string Boy::description()
{
	stringstream ret;
	ret << "姓名:" << name << "\t年龄:" << age << "\t薪资:" << salary << "\t黑马系数" << darkHorse << "\tID:" <<id;

	return ret.str();
}

Boy& Boy::operator=(const Boy & boy)
{
	if (name) {
		delete name;
	}
	name = new char[strlen(boy.name) + 1];

	strcpy_s(name, strlen(boy.name) + 1, boy.name);
	
	this->age = boy.age;
	this->salary = boy.salary;
	this->darkHorse = boy.darkHorse;

	return *this;
}

main函数：

#include <iostream>
#include "Boy.h"

int main() {
	Boy boy1("rock", 30, 20000, 3);
	Boy boy2, boy3;
	
	cout << boy1.description() << endl;
	cout << boy2.description() << endl;
	cout << boy3.description() << endl;
	
	boy3 = boy2 = boy1;
	cout << boy1.description() << endl;
	cout << boy2.description() << endl;
	cout << boy3.description() << endl;
	
	return 0;
}

- 重载关系运算符（> < ==）

直接比较boy（即 boy1>boy2 / boy1<boy2 / boy1==boy2）

boy头文件：

#pragma once
#include <string>

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();

	string description();
	bool operator>(Boy &boy);
	bool operator<(Boy &boy);
	bool operator==(Boy &boy);

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
	int compareBoys() const;
};

boy实现类

#include <sstream>
#include "Boy.h"

int Boy::lastId = 0;

Boy::Boy(const char * name, int age, int salary, int darkHorse)
{
	if (!name) {	//判断name是否为空
		name = "无名";
	}
	
	this->name = new char[strlen(name)+1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;

	id = ++lastId;
}

Boy::~Boy()
{
	delete name;
}

string Boy::description()
{
	stringstream ret;
	ret << "姓名:" << name << "\t年龄:" << age << "\t薪资:" << salary << "\t黑马系数" << darkHorse << "\tID:" <<id;

	return ret.str();
}

bool Boy::operator>(Boy & boy)
{
	if (this->compareBoys() > boy.compareBoys()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator<(Boy & boy)
{
	if (this->compareBoys() < boy.compareBoys()) {
		return true;
	}
	else {
		return false;
	}
}

bool Boy::operator==(Boy & boy)
{
	if (this->compareBoys() == boy.compareBoys()) {
		return true;
	}
	else {
		return false;
	}
}

int Boy::compareBoys()const
{
	int coefficient = salary + (100-age) * 10 + darkHorse * 100;
	return coefficient;
}

main函数：

#include <iostream>
#include "Boy.h"

int main() {
	Boy boy1("rock", 30, 20000, 3);
	Boy boy2("martin", 25, 35000, 5);

	if (boy1 > boy2) {
		cout << "rock更值得选择" << endl;		
	}else if(boy1 < boy2){
		cout << "martin更值得选择" << endl;
	}
	else if (boy1 == boy2) {
		cout << "不分伯仲" << endl;
	}
	
	return 0;
}

- 重载关系运算符[ ]

对象访问使用：对象名[下标]，下标使用字符串或数字
[例] 访问boy的age，boy[“age”] 或 boy[0]

boy头文件：

#pragma once
#include <string>

#define AGE_KEY			"age"
#define	SALARY_KEY		"salary"
#define DARK_HORSE_KEY  "darkHorse"

typedef enum
{
	AGE,
	SALARY,
	DARK_HORSE,
	POWER
} arr;

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();

	string description();

	int operator[](string index);	//下标运算符重载，输入字符串，返回年龄/薪资/黑马系数
	int operator[](int index);	//下标运算符重载，输入数字，返回年龄/薪资/黑马系数

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
	int compareBoys() const;
};

boy类实现：

#include <sstream>
#include "Boy.h"

int Boy::lastId = 0;

Boy::Boy(const char * name, int age, int salary, int darkHorse)
{
	if (!name) {	//判断name是否为空
		name = "无名";
	}
	
	this->name = new char[strlen(name)+1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;

	id = ++lastId;
}

Boy::~Boy()
{
	delete name;
}

string Boy::description()
{
	stringstream ret;
	ret << "姓名:" << name << "\t年龄:" << age << "\t薪资:" << salary << "\t黑马系数" << darkHorse << "\tID:" <<id;

	return ret.str();
}

int Boy::operator[](string index)
{
	if (index == "age") {
		return age;
	}
	else if (index == "salary") {
		return salary;
	}
	else if (index == "darkHorse") {
		return darkHorse;
	}
	else if (index == "power") {
		return compareBoys();
	}
	else {
		return -1;
	}
}

int Boy::operator[](int index)
{
	if (index == 0) {
		return age;
	}
	else if (index == 1) {
		return salary;
	}
	else if (index == 2) {
		return darkHorse;
	}
	else if (index == 3) {
		return compareBoys();
	}
	else {
		return -1;
	}
}

int Boy::compareBoys()const
{
	int coefficient = salary + (100-age) * 10 + darkHorse * 100;
	return coefficient;
}

main函数：

#include <iostream>
#include "Boy.h"

int main() {
	Boy boy1("rock", 30, 20000, 3);
	Boy boy2("martin", 25, 35000, 5);

	cout << "年龄:" << boy1[AGE_KEY] << endl;
	cout << "薪资:" << boy1[SALARY_KEY] << endl;
	cout << "黑马系数:" << boy1[DARK_HORSE_KEY] << endl;
	cout << "综合系数:" << boy1["power"] << endl;

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

	cout << "年龄:" << boy2[AGE] << endl;
	cout << "薪资:" << boy2[SALARY] << endl;
	cout << "黑马系数:" << boy2[DARK_HORSE] << endl;
	cout << "综合系数:" << boy2[POWER] << endl;
	
	return 0;
}

- 重载输入、输出运算符（>> <<）

方式一：使用成员函数（没有实际意义，不建议使用）
方式二：使用友元函数

boy头文件：

#pragma once
#include <string>

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();
	
	string description();

	//使用友元函数来实现输出输入运算符的重载
	friend ostream &operator<<(ostream &os, const Boy &boy);
	friend istream &operator>>(istream &is, Boy &boy);

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
	int compareBoys() const;
};

boy类实现与前一节相同

main函数：

#include <iostream>
#include "Boy.h"

ostream &operator<<(ostream &os, const Boy &boy) {

	os << "姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:" << boy.salary << "\t黑马系数" << boy.darkHorse;

	return os;

}

istream &operator>>(istream &is, Boy &boy) {
	string defName;

	is >> defName >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = new char[defName.length() + 1];						//申请内存空间
	strcpy_s(boy.name, defName.length() + 1, defName.c_str());		//拷贝给boy的name
	
	return is;
}

int main() {
	Boy boy1("rock", 30, 20000, 3);
	Boy boy2("martin", 25, 35000, 5);

	cout << boy1 << endl;
	cout << boy2 << endl;
	
	return 0;
}

- 重载输入、输出运算符（>> <<）

① 普通类型转为类类型

[例] 只输入boy的薪资，boy的薪资将会被赋值
方法：创建一个构造函数

boy头文件：

#pragma once
#include <string>

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();
	
	string description();

	//普通类型转换为类类型
	Boy(int salary);
	Boy(char* name);

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
};

boy类实现：

#include <sstream>
#include "Boy.h"

int Boy::lastId = 0;

Boy::Boy(const char * name, int age, int salary, int darkHorse)
{
	if (!name) {	//判断name是否为空
		name = "无名";
	}
	
	this->name = new char[strlen(name)+1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;

	id = ++lastId;
}

Boy::~Boy()
{
	delete name;
}

Boy::Boy(int salary)
{
	const char *name = "无名";
	this->name = new char[strlen(name) + 1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->salary = salary;
	this->age = 0;
	this->darkHorse = 0;

	id = ++lastId;
}

Boy::Boy(char * name)
{
	this->name = new char[strlen(name) + 1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->salary = 0;
	this->age = 0;
	this->darkHorse = 0;

	id = ++lastId;
}

main函数：

#include <iostream>
#include "Boy.h"

ostream &operator<<(ostream &os, const Boy &boy) {

	os << "姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:" << boy.salary << "\t黑马系数" << boy.darkHorse;

	return os;

}

istream &operator>>(istream &is, Boy &boy) {
	string defName;

	is >> defName >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = new char[defName.length() + 1];						//申请内存空间
	strcpy_s(boy.name, defName.length() + 1, defName.c_str());		//拷贝给boy的name
	
	return is;
}

int main() {
	Boy b1(10000);
	Boy b2("张分散");
	
	cout << boy1.description() << endl;
	cout << boy2.description() << endl;
	
	return 0;
}

② 类类型转为普通类型

[例] 输入男生的所有信息，把这个对象赋值给男生类中的某个数据成员，可以改变数据成员的内容

boy头文件：

#pragma once
#include <string>

using namespace std;

class Boy
{
public:
	Boy(const char *name = NULL, int age = 0, int salary = 0, int darkHorse = 0);
	~Boy();
	
	string description();
	
	//类类型转换为普通类型
	operator int() const;
	operator char* () const;

private:
	char *name;
	int age;
	int salary;
	int darkHorse;	//黑马系数
	int id;
	static int lastId;
};

boy类实现：

#include <sstream>
#include "Boy.h"

int Boy::lastId = 0;

Boy::Boy(const char * name, int age, int salary, int darkHorse)
{
	if (!name) {	//判断name是否为空
		name = "无名";
	}
	
	this->name = new char[strlen(name)+1];	//申请内存来存储名字
	strcpy_s(this->name, strlen(name) + 1, name);

	this->age = age;
	this->salary = salary;
	this->darkHorse = darkHorse;

	id = ++lastId;
}

Boy::~Boy()
{
	delete name;
}

Boy::operator int() const
{
	return compareBoys();
}

Boy::operator char*() const
{
	return name;
}

main函数：

#include <iostream>
#include "Boy.h"

ostream &operator<<(ostream &os, const Boy &boy) {

	os << "姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:" << boy.salary << "\t黑马系数" << boy.darkHorse;

	return os;

}

istream &operator>>(istream &is, Boy &boy) {
	string defName;

	is >> defName >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = new char[defName.length() + 1];						//申请内存空间
	strcpy_s(boy.name, defName.length() + 1, defName.c_str());		//拷贝给boy的name
	
	return is;
}

int main() {
	Boy b3("张三",20,30000,4);

	int power = b3;
	char *name = b3;

	cout << power << endl;
	cout << name << endl;*/
	
	return 0;
}

③ 类类型转为类类型

有一个新的类man 可以直接将boy对象赋值给man对象
方法：修改man的构造方法

man头文件：

#pragma once
#include <iostream>

using namespace std;

class Boy;

class Man
{
public:
	Man(Boy &boy);
	~Man();

	friend ostream &operator<<(ostream &os, const Man &man);

private:
	char *name;
	int age;
	int salary;
};

man实现类：

#include "Man.h"
#include "Boy.h"

Man::Man(Boy &boy)
{
//	int length = strlen(boy.getName());
	int length = strlen((char*)boy);
	name = new char[length+1];

	strcpy_s(name, length + 1, boy.getName());

	age = boy[AGE];
	salary = boy[SALARY];
}

Man::~Man()
{
	delete name;
}

ostream &operator<<(ostream &os, const Man &man) {

	os << "姓名:" << man.name << "\t年龄:" << man.age << "\t薪资:" << man.salary;

	return os;

}

main函数：

#include <iostream>
#include "Boy.h"

ostream &operator<<(ostream &os, const Boy &boy) {

	os << "姓名:" << boy.name << "\t年龄:" << boy.age << "\t薪资:" << boy.salary << "\t黑马系数" << boy.darkHorse;

	return os;

}

istream &operator>>(istream &is, Boy &boy) {
	string defName;

	is >> defName >> boy.age >> boy.salary >> boy.darkHorse;
	boy.name = new char[defName.length() + 1];						//申请内存空间
	strcpy_s(boy.name, defName.length() + 1, defName.c_str());		//拷贝给boy的name
	
	return is;
}

int main() {
	Boy boy("张三", 35, 50000, 4);
	Man man(boy);

	cout << boy << endl;
	cout << man << endl;
	
	return 0;
}

[注] = () [ ] -> 这四种运算符不能使用友元函数进行重载

不能被重载的运算符：

类别符号
成员访问.
域运算::
内存长度运算sizeof
三目运算? : :
预处理#

可以被重载的运算符：

类别符号
双目运算符+ - * / %
关系运算符== != < <= > >=
逻辑运算符与 或 非
单目运算符+(正号) -（负号） *（指针） &（取地址） ++ –
位运算&
赋值运算符= += -= *= /= %= &=
内存分配new delete new[ ] delete[ ]
其他( ) 函数调用 -> 成员访问 [ ] 下标 ， 逗号

总结：项目13学的时间太久了，丧失了学习动力，中间有两个星期没能坚持，学习真的是一件孤独且容易放弃的事，后面的学习要继续努力！不因有效果而坚持，应坚持才产生效果，奥利给！！！

独爱莫宝的三岁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习周记-第一周
dongwenpu的专栏
03-18 1370
由于想要进行MFC的学习，这周我开始学习C++语言，由于是初学C++，我希望能记下我学习C++语言的点点滴滴，以供今后回味。 C++是面向对象的语言，而C是面向过程的语言，因此两者还是有不小的差异，但C++兼容C语言，因此C语言也能在C++的环境中编写，C++的基本语法与C基本类似，而在C的基础上增加了OOP编程。 刚接触C++，我觉得先熟悉C++的语言，因此选《C++ primer plus》
第三周c++周报
apple_51336699的博客
01-31 353
顺序容器 STL deque 类 1.deque 是一个动态数组 2.deque与vector非常类似 3.deque可以在数组开头和末尾插入和删除数据 问：如何创建一个动态数组? 答：deque<数据类型>数组名； 例如：deque<数据类型>a; 问：如何插入数据？ 答： 数组名.push_back(值);//这是在末尾插入数据 数组名.push_front(值);//这是在开头插入数据 问：如果删除数据？ 答： 数组名.pop_back();//这是删除末尾数据 数组名.p.
C++及QT5.12.6学习日记第一周（3.1-3.7）
z377989129的博客
03-05 493
3.文件中可能会缺少Windows Kits下的库，它在安装VS时会同步安装，注意它可能不在C盘，其他盘也要多找找；倘若都没有，可使用Visual Studio Installer重新进行安装。安装Visual Studio2017、Qt5.12.6、QGIS3.22.16（以备以后GIS开发时使用）C++常用编译器有：DevC++、VC++6.0、Visual Studio等。2.在Qtcreater中无法打开某一个库，添加系统环境变量。5. qt的安装：注意组件的选择。软件安装与环境配置V。
C++程序设计1~6周学习总结
sdjcwangwei的博客
04-06 371
内容概要递归算法复合数据类型结构体类型枚举类型string指针引用类和对象类的定义访问控制成员函数对象对象的定义定义对象时注意要点类成员的访问对象成员的访问形式指针访问形式类定义和使用时的注意要点内联函数内联函数作用内联函数机制内联函数声明成员函数类内实现（内联函数）函数重载构造和析构函数默认构造函数构造函数的初始化列表带默认值的构造函数默认析构函数this指针复制构造函数浅复制与深复制类的其他成...
学习周报.pdf
02-07
学习周报
2021年1月4日C++学习
genemaxblog
01-04 93
21.指针：通过指针间接访问内存 （1）指针的基本概念 1）内存编号从0开始记录，一般用十六进制数字表示； 2）利用指针变量保存地址 （2）指针变量的定义和使用 1）指针变量定义语法： 数据类型 *变量名； 2）&:取址符号 int a = 10; int * p; p=&a;（int *p = &a;） *：解引用符号 a = *p; （3）指针所占用的内存空间：指针也是一种数据类型 1）指针所占内存空间 sizeof(int *);sizeof(double *); 2
2021年一周学习总结笔记.docx
11-27
【一周学习总结笔记】 在这一周的学习中，主要聚焦于C++编程语言、虚拟机环境配置、MBoot的深入理解和Linux相关知识。首先，周一的重点是搭建虚拟机环境，安装必要的软件，并开始重新熟悉C++基础，特别是指针和类的...
《Java程序设计》第一周学习总结.docx
12-27
在《Java程序设计》第一周的学习中，我们深入了解了Java语言的基本历史和发展，以及它在不同平台上的应用。Java起源于Sun公司的Green项目，最初是为了创建一个分布式代码系统，目标是实现家用电器间的通信。由于C++...
4.13-C++周作业.docx
最新发布
03-30
根据给定文件的信息，我们可以将相关的C++知识点总结如下： ### 一、判断三个double类型的数值能否构成三角形 #### 题目描述 输入3个`double`类型的数值，判断这三个数值是否能够构成一个三角形的三边。具体而言，...
MP3.zip_C++设计一个mp3_c++简易程序_播放Mp3
09-20
总结来说，设计一个C++ MP3播放器涉及音频解码、文件操作、用户交互、播放控制、硬件交互等多个方面，需要综合运用多种技术和库。通过这个项目，不仅可以学习到C++编程技巧，还能深入理解多媒体处理和系统级别的交互...
我的c++第一节课.doc
04-18
C++程序设计基础知识点总结 本资源摘要信息将对C++程序设计基础知识点进行总结和解释，涵盖循环结构、变量定义、自增运算符、输入输出操作等基础知识点。 循环结构 循环结构是C++程序设计中的一种基本结构，用于...
第一小组第九周学习周报
qq_42174885的博客
11-04 255
第九周学习周报 （2018.10.29-11.04） 一、本周学习情况 1、本周主要复习了c语言 参照翁恺老师的C语言课程，对基础进行了一次巩固。还对扩展了一些没有学到过的知识。例如二进制文件输入输出，预编译处理与宏，计算机传输数据时大小端的区别，通过定义位段来控制位运算的操作 2、看了Arduino入门课程的部分视频 3、做了“闪烁的LED”，“流水灯”等实验 二、学习笔记 这周复习了c语言，参...
学习周报
zllll11111的博客
11-10 3020
第十周学习周报 (2018.11.5-2018.11.11) 一、本周学习情况 1.观看了Arduino...
C++ 继承关系
lovehang99的博客
04-26 3864
1.继承的概念及定义 1.1继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 1.2继承定义 1.2.1继承的格式 1.2.2继承关系和访问限定...
03/09~03/15 学习周报
ladream的博客
03-15 151
【本周总结】 1.学习了::before和::after ：包括content的值、利用伪元素实现三角形，六边形，对话框、利用伪元素做出箭头的形状、清除浮动、实现一些标签对placeholder的支持 2.完善之前的页面 3.新学了一些css属性： display:table； display:table-cell; placeholder、transform：translation(X,Y);...
2019.5.12学习周报
Benjalin_76_84的博客
05-12 1341
继续Servlet 1、与属性相关的方法 方法： Object getAttribute（String name）； 获取指定的属性 Enumeration getAttributeNames（）； 获取所有属性名字组成的Enumeration对象 boolean removeAttribute（String name）； 移除属性 void setAttribute（String name...
《C++》10 C++ 类 & 对象
HerGhost
03-28 469
C++ 类 & 对象C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类被称为类的成员。 C++ 类定义 定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就
Visual C++ 6 学习之旅：21天掌握德语版 C++
同样，在这一周结束时进行了总结，帮助学习者理清脉络。 第三周的学习重点转向数据处理，包括使用ADO操作数据库，编写自定义的C++类和模块，理解和使用动态链接库（DLL），以及多任务编程。此外，还涉及了创建自己...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值