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

最新推荐文章于 2023-09-24 14:34:39 发布
原创 最新推荐文章于 2023-09-24 14:34:39 发布 · 426 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文详细介绍了C++中的友元概念及其实现方法，包括友元函数和友元类，并深入探讨了多种运算符重载的方式，如成员函数、友元函数等，以及不同类型之间的转换。

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学的时间太久了，丧失了学习动力，中间有两个星期没能坚持，学习真的是一件孤独且容易放弃的事，后面的学习要继续努力！不因有效果而坚持，应坚持才产生效果，奥利给！！！

C++学习周记-第一周
dongwenpu的专栏
03-18 1459
由于想要进行MFC的学习，这周我开始学习C++语言，由于是初学C++，我希望能记下我学习C++语言的点点滴滴，以供今后回味。 C++是面向对象的语言，而C是面向过程的语言，因此两者还是有不小的差异，但C++兼容C语言，因此C语言也能在C++的环境中编写，C++的基本语法与C基本类似，而在C的基础上增加了OOP编程。 刚接触C++，我觉得先熟悉C++的语言，因此选《C++ primer plus》
【C++】C++学习笔记基础语法
qq_48419442的博客
05-06 1031
系统学习C++开发，需要用到的所有C语言知识，以及个人对难理解部分的学习总结，比如二维数组的指针调用等。
第十四周C++学习总结
抒情诗
05-18 184
类模板使用方法：类模板名 <数据类型> 对象名； C++有个标准模板库(STL)（standard template library），编程时使用它会提高程序的可靠性。 Stl 包含了（容器，算法，迭代器） 容器：容纳，包含相同元素的对象，主要用类模板实现， 序列型容器： vector 向量 List 双向链表 Deque 双端队列 关联型容器： map 映射 Set 集合 容器适配器： stack 栈 Queue 队列 迭代器： 是用于确定元素位置的数据类型,可用来遍历容器中的元素 通过迭代.
第三周c++周报
apple_51336699的博客
01-31 435
顺序容器 STL deque 类 1.deque 是一个动态数组 2.deque与vector非常类似 3.deque可以在数组开头和末尾插入和删除数据 问：如何创建一个动态数组? 答：deque<数据类型>数组名； 例如：deque<数据类型>a; 问：如何插入数据？ 答： 数组名.push_back(值);//这是在末尾插入数据 数组名.push_front(值);//这是在开头插入数据 问：如果删除数据？ 答： 数组名.pop_back();//这是删除末尾数据 数组名.p.
学习周报
qq_44832130的博客
06-23 307
#include "../View/Account_UI.h" #include<stdio.h> #include "../Common/List.h" #include "../Service/Account.h"
C++及QT5.12.6学习日记第一周（3.1-3.7）
z377989129的博客
03-05 710
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。
2021年一周学习总结笔记.docx
11-27
【一周学习总结笔记】 在这一周的学习中，主要聚焦于C++编程语言、虚拟机环境配置、MBoot的深入理解和Linux相关知识。首先，周一的重点是搭建虚拟机环境，安装必要的软件，并开始重新熟悉C++基础，特别是指针和类的...
《Java程序设计》第一周学习总结.docx
最新发布
06-30
Java程序设计第一周学习总结涉及了Java语言的起源、版本演进以及Java三大平台的基础知识。Java语言最初是作为Sun公司Green项目的一部分出现的，旨在为家用消费电子产品开发分布式代码系统。由于C++语言的复杂性和...
学习C++的周期计划书
m0_74293254的博客
09-24 1136
C++是一种通用的编程语言，广泛应用于计算机科学和软件开发领域。对于刚进入编程界的人来说，学习C++是一个不错的选择。然而，学习一门编程语言并不是一件容易的事情，需要耐心和毅力。那么，学习C++到底要多久才能入门呢？如何学才能更有效呢？本文将分享一些学习C++的经验，给想学的人一个学习的方向。
本周c++学习小结和心得
qq_62777279的博客
03-28 1050
上网课的时间过得真快，不知不觉一周又过去了。感觉上一次写博客仿佛就在昨天。这周费老向我们发了一个ICPC省赛，我犹豫再三，最终还是决定不去。因为我清楚我自己的实力，我明白以我现在的水平去参加比赛感觉就像是鸡蛋碰石头，所以还不如现在先储精蓄锐到大二再去参加，至少会比我现在更有水平一点，获奖虽然很难，但我也想去见识见识。 那接下来就说一说我这一周都干了些什么吧。平常我都是在空闲之余看“算法笔记”最近研究哪一部分内容就挑哪一部分看，由于现在是线上教学，感觉整体进度都慢了一丝丝，所以平常也多出了更多空闲的时间。但
学习周报.pdf
02-07
学习周报
c++培训周总结1
tmsh113的专栏
11-12 624
201310总结  培训部分 ： char 8个比特位  1字节  short 16个比特位  2字节  long int 32个比特位 4字节  在32位机器上int为long int float 和long int一样  double 8字节  long long int 8字节 long double 12字节 bool类型需要外部载入 stdbool.h
C++学习一周总结（2021/03/07）
jjswift的博客
03-07 168
继承和派生 - 代码实现 父类（基类） class Father{ public: string getName() const; int getAge() const; private: string name; int age; } 子类，继承father类，拥有father类的方法与数据成员 class Son : public Father{ public: string getGame(); private: string game; } - 子类对象的内存分布 先给子
C++一周学习总结（2021/06/27）
jjswift的博客
07-07 225
STL容器
c++培训周总结2
tmsh113的专栏
11-18 793
培训部分 数组名有两个含义 1  代表数组首地址 2 代表数组变量 当对数组名取地址的时候 ，为第二种用法，此时整个数组看做是一个整体，取珍整个数组的首地址，形式上看做把一个一维数组变成了一个二维数组 数组在内存中是连续存放的 通过测试发现连续声明两个数组的位置也是连续的 静态变量会自动初始化为0 用变量指定数组的个数的数组叫变长数组，在C9
C++三周心得总结
yingyudou的博客
04-12 319
       从零基础到入门，从输出 Hello World！到能A掉用数学可以做一下午的题，我越来越感觉到信息技术的神奇……以前印象中程序员敲代码就是，手指一顿狂敲，然后打出来的一大堆东西啥也看不懂……经过这三周的初步学习，我不仅开始能理解一些简单的代码，而且发现敲代码刷题贼有趣……      学信奥一是可以争取保送、降分资格，二是在这种年代学点信息技术也是必要的。而且我本身对此也很有兴趣，敲一...
c++核心编程第一部分讲义_耗时一周，一万字总结C++提高编程二STL第一部分，确定不点个收藏
weixin_39913105的博客
11-28 282
1，STL初识1.1 目的为了创建一种可重复利用的东西，C++中的面向对象和泛型编程思想，就是复用性的提升STL是为了建立数据库和算法的一套标准1.2 基本概念STL:标准模板库STL从广义上分为：容器，算法，迭代器容器和算法之间通过迭代器进行无缝连接STL几乎所有的代码都采用了模板类或者模板函数1.3 STL六大组件STL分为六大组件：容器，算法，迭代器，仿函数，适配器(配接器)，空间配置器容器...
C++程序设计1~6周学习总结
sdjcwangwei的博客
04-06 475
内容概要递归算法复合数据类型结构体类型枚举类型string指针引用类和对象类的定义访问控制成员函数对象对象的定义定义对象时注意要点类成员的访问对象成员的访问形式指针访问形式类定义和使用时的注意要点内联函数内联函数作用内联函数机制内联函数声明成员函数类内实现（内联函数）函数重载构造和析构函数默认构造函数构造函数的初始化列表带默认值的构造函数默认析构函数this指针复制构造函数浅复制与深复制类的其他成...
04/20~04/26 学习周报
ladream的博客
04-26 184
【本周总结】 1.学习了js红宝书第五章、第六章、和第七章的递归、闭包 2c语言课学习到函数，做了相关题目 3.复习了离散的内容，进行了离散的测试 4.自己写了一些c语言题目 【下周计划】 1.做好周报总结 2.学习课内知识，写c语言题 3.完成实验室任务 4.背单词 【遇到的问题&思考】 1.有时写c语言题总是刚开始想的很复杂，尝试了一段时间后发现实现不了，然后再换个思路重新开始写，就会...
Java程序设计第一周学习总结与核心概念梳理
资源摘要信息:"《Java程序设计》第一周学习总结.docx"是一份由学生撰写的关于其在2016-2017学年第二学期初学习Java编程语言的阶段性总结文档。该文件记录了作者在进入Java系统化学习第一周后对教材第一章和第二章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值