C++学习笔记——拾遗

已于 2022-05-31 01:18:25 修改
阅读量996 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 学习
于 2022-03-11 14:44:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxsy024680/article/details/123424518
版权

1、指针大小
sizeof(int *)为4，sizeof(float *)为4， sizeof(char *)也为4，存放地址4个字节就够了，int、float、char指的是地址上的数据的类型。

2、空指针，如int * buf = NULL
空指针指向内存编号为0x00000000的地方，此处是不可以读写的，一般用于指针初始化。其实0x00000000~0x000000FF之间的内存都是系统占用的，都不可以读写。

3、野指针，如int * buf=(int *)0x00001100
0x00001100这个地址我们不认识，如此赋值可能导致程序运行异常。空指针和野指针都不是我们申请的空间，因此不要访问。

4、常量指针，如int a=10; int b=10; const int * p = &a; p=&b;
指针的指向可以修改，但指针指向的值不可以修改。

5、指针常量，如int a=10; int * const p = &a; *p=20;
指针的指向不可以修改，但指针指向的值可以修改。

6、修饰常量，如int a=10; const int * const p = &a;
指针的指向不可以修改，指针指向的值也不可以修改。

7、结构体
结构体，自建数据类型，如学生数据类型

struct student{
string name;
int age;
int score;
}s3;

// 方式1，类似于int a;a=3;
student s1;
s1.name = "张三";
s1.age = 28;
s1.score = 98;

// 方式2，类似于int a=3;
student s2={"李四",29,99};

// 方式3
s3.name = "王五";
s3.age = 30;
s3.score = 100;

// 结构体指针，类似于int a;a=3;int *p=&a;
student *p1 = &s1;
cout<<p1->name<<p1->age<<p1->score<<endl;

8、结构体嵌套结构体

# include <iostream>
# include <string>
using namespace std;

struct student
{
	string name;
	int age;
	int score;
};

struct teacher
{
	string name;
	int age;
	student stu;
};

int main(){
	teacher t;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 20;
	t.stu.score = 100;

	cout << t.name << "   " << t.age << "   " << t.stu.name << "   " << t.stu.age << "   " << t.stu.score << endl;

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

9、形参与实参
定义函数时，括号里的参数是形参，调用函数时，括号里的参数是实参。不管传递值还是传递地址，形参都是实参的复制，当实参很大很大时，如一个学校全体学生的数据，复制一个同样大小的形参，电脑内存可能溢出，如果传递地址，则只需要4个字节的空间，显然更好。但也要注意，传递地址时地址上的数据可能在子函数中被无意篡改，为了预防这个隐患，形参可以使用常量指针。

10、随机数

srand((unsigned int)time(NULL));//随机数种子
int random = rand()%21+80; //80~100

11、全局区
写在函数体外面的变量是全局变量。
在全局变量前面加上const就是全局常量。
在局部变量前面加上static就是静态变量。
全局变量、全局常量、静态变量存放在全局区。
全局区的数据在程序执行结束后自动释放。

12、栈区
写在函数体里面的变量是局部变量。
在局部变量前面加上const就是局部常量。
局部变量、局部常量存放在栈区。
栈区的数据在函数执行结束后自动释放，所以函数不要返回局部变量或局部常量的地址，因为这样得不到我们想要的数据。

13、堆区
new创建的数据存放在堆区，并返回一个地址，如int *p = new int(10);int* arr = new int[10];。
堆区的数据由程序员释放，如delete p;delete[] arr;，如果程序员没有释放，在程序执行结束后自动释放。

14、引用
引用的作用是给变量起别名。
引用必须初始化，初始化之后不可以更改。
不能返回局部变量引用。
如果函数的返回值是引用，那么这个函数调用可以作为左值。
引用本质上是一个指针常量。
常量引用本质上是一个修饰常量。

int a =10;
int &b = a;
b = 20;
cout<<a<<endl;//结果为20

# include <iostream>
# include <string>
using namespace std;

int& test()
{
	//不能返回局部变量引用，所以需要定义为静态变量
	static int a = 10;
	return a;
}

int main(){
	int &b = test();
	cout << b << endl;//结果为10
	cout << b << endl;//结果为10

	test() = 1000;

	cout << b << endl;//结果为1000
	cout << b << endl;//结果为1000

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

# include <iostream>
# include <string>
using namespace std;

void show(const int & val)
{
	// val = 1000;//不允许修改常量引用的值
	cout << val << endl;//结果是10
}

int main(){
	int a = 10;
	show(a);

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

15、万事万物皆为对象，对象有其属性和行为。具有相同性质的对象可以抽象称为类。

16、构造函数：主要作用在于创建对象时为对象的成员属性赋值，由编译器自动调用，无需手动调用。
析构函数：主要作用在于对象销毁前执行一些清理工作，由编译器自动调用，无需手动调用。

# include <iostream>
# include <string>
using namespace std;

class Person
{
public:
	Person()
	{
		cout << "Person的无参构造函数" << endl;
	}

	Person(int age, int height)
	{
		m_age = age;
		m_height = new int(height);
		cout << "Person的有参构造函数" << endl;
	}

	Person(const Person &p)
	{
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		cout << "Person的拷贝构造函数" << endl;
	}

	~Person()
	{
		delete m_height;
		cout << "Person的析构函数" << endl;
	}

	int m_age;
	int * m_height;
};

void test()
{
	Person p1;
	Person p2(10, 160);
	Person p3(p2);
	cout << "p3.m_age = " << p3.m_age << "   *p3.m_height = " << *p3.m_height << endl;
}

int main(){
	test();

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

在这里插入图片描述

17、默认情况下，C++编译器至少给一个类提供3个函数：
（1）默认无参构造函数，函数体为空；
（2）默认拷贝构造函数，对属性进行值拷贝;
（3）默认析构函数，函数体为空;
如果用户定义有参构造函数，C++不再提供无参构造函数；
如果用户定义拷贝构造函数，C++不再提供无参构造函数，也不再提供有参构造函数；

18、静态变量与静态函数

# include <iostream>
# include <string>
using namespace std;

class Person
{
public:
	static void fun()
	{
		m_A = 200;
		// m_B = 200; 静态函数只能调用静态变量
	}

	static int m_A;
	int m_B;
};

// 静态变量在类外初始化
int Person::m_A = 100;

void test()
{
	Person p1;
	cout << "p1.m_A=" << p1.m_A << endl; //100
	cout << "Person::m_A=" << Person::m_A << endl; //100

	p1.fun(); // 对象调用静态函数
	Person::fun(); // 类调用静态函数
	cout << "p1.m_A=" << p1.m_A << endl; //200
	cout << "Person::m_A=" << Person::m_A << endl; //200

	Person p2;
	p2.m_A = 300; // 所有对象共用静态变量
	cout << "p1.m_A=" << p1.m_A << endl; //300
	cout << "Person::m_A=" << Person::m_A << endl; //300

}

int main(){
	test();

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

19、只有非静态成员变量属于类的对象上

# include <iostream>
# include <string>
using namespace std;

class Person
{
public:
	int m_A;                              //非静态成员变量 属于 类的对象上
	static int m_B;                       //静态成员变量 不属于 类的对象上
	int get_A(){ return m_A; }            //非静态成员函数 不属于 类的对象上
	static int get_B(){ return m_B; }     //静态成员函数 不属于 类的对象上
};
int Person::m_B = 0;

void test()
{
	Person p;
	cout << "sizeof(p)=" << sizeof(p) << endl; //sizeof(p)=4
}

int main(){
	test();

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

20、this指针指向被调用的成员函数所属的对象

# include <iostream>
# include <string>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		this->age = age; //this指针指向被调用的成员函数所属的对象
		//m_age = age;
	}

	Person& PersonAddAge(Person p) // 返回的是对象的引用，不会重新创建一个对象
	{
		this->age += p.age;
		return *this; // *this为被调用的成员函数所属的对象
	}

	int age;
	//int m_age;
};

void test()
{
	Person p1(10);
	Person p2(10);
	cout << "p1.age=" << p1.age << endl; // p1.age=10
	cout << "p2.age=" << p2.age << endl; // p2.age=10
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "链式调用后p2.age=" << p2.age << endl; // p2.age=40
	
}

int main(){
	test();

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}

21、常对象与常函数

# include <iostream>
# include <string>
using namespace std;

class Person
{
public:
	void fun()
	{
		m_A = 100;
	}

	// this指针的本质是指针常量，类似于Person * const this
	// 在成员函数后面加上const，this指针的本质就是修饰指针，类似于const Person * const this
	void showPerson() const //常函数
	{
		// this = NULL; // this指针的指向不可以修改
		// this->m_A = 100; // this指针指向的值不可以修改
		this->m_B = 100;
	}
	int m_A;
	mutable int m_B; // 特殊变量，在常函数中可以修改
};

void test()
{
	const Person p; // 常对象
	// p.fun(); // 常对象只能调用常函数
	p.showPerson();
}

int main(){
	test();

	// 命令行窗口不要关闭
	system("pause");

	return 0;
}
wxsy024680
关注
专栏目录
B站黑马c++学习笔记 —— 基础入门篇
qq_52382976的博客
10-28 2458
1. 初识 1.1 常量 #define day 7 const int month 12; 1.2 关键字 2. 数据类型 数据类型：给变量分配合适的内存空间 2.1 整型 2.2 sizeof关键字 2.3 实型（浮点型） float f1 = 3.14f; double d1 = 3.14; 2.4 字符型 2.5 字符串型 c风格： char str[] = "hello word"; c++风格： string str = "hello word"; c++风格 要加入
Modern C++ 学习笔记——C++面向对象编程
小小笑笑川的博客
07-02 982
结合三种设计模式，让你更加理解C++面向对象的特性，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
4 数组
weixin_40569915的博客
11-28 587
1.1 数组 数组方便一次定义大量变量空间，而且也方便访问，访问时利用地址累加，访问每个数组空间即可。 1.1.1 一维数据中的关键符号 以int buf[100] = {0} 为例 buf：一是数组名，sizeof(buf)时，buf就是数组名的含义；二是等价于&amp;amp;amp;amp;amp;buf[0]，表示数组第一个元素的首字节地址，是一个常量值。 buf[0]：第一个元素的空间，可以对其进行读写操作。 &amp;amp;amp;amp;amp...
char* buf和char buf[64]，定义两种字符串作为参数传递给函数的区别
qq_42230338的博客
06-23 5170
问题描述： 最近在项目中遇到了一个让人疑惑的问题，有一个发送函数需要传递void*类型的参数，我定义了char *buf = “abcdefg”； 然后将buf作为参数传递给了这个发送函数，但是函数返回值显示发送成功，但是另一端没有接收到数据。查找了好久， 最终我将char *buf = “abcdefg”，改为char buf[64] = “abcdefg”；然后再次传输，结果传输成功。 总结： 以后遇到这种情况可以直接分配具体的数组空间。 ...
什么时候用指针的指针 **
fengyunjh6的专栏
08-22 4623
比如声明u32 **buf 这个buf要作为一个函数的参数，这个函数的作用是告诉bufni
c语言指针进阶（二）
viafcccy的博客
12-03 375
    指针不断的改变指向和多个指针操作一个内存空间 首先这里强调一个问题就是假设我现在知道一个内存地址0xaa11 我怎样将这个地址直接给一个指针呢？ 首先这样是没有语法错误的 确实也是这样定义的 但是地址我们是不能随便规定的 这个主要用于程序开发中我们向特定的地址（我们已知的地址）去写入数据（例如：通过I2C接口发送到MCU一个地址数据（unsigned char AdData)，一个待...
c语言
wzg31796的博客
05-05 671
一、c基础 1.1 一个函数遇到return语句就终止了 1.2 system系统调用：用命令打开计算器、记事本等，windows和linux下命令不同，需要头文件（stdlib.h） 1.3 gcc -o a a.c  ：-o为指定输出程序后缀，如果不加-o，gcc a.c windows下生成a.exe，linux下生成a.out 1.4 编译过程 1.5 -E预编译：g
2020.2.10C++学习笔记——C++操作Mysql事务机制（回滚）
CQ的学习笔记
02-10 2181
C++学习笔记——C++操作Mysql事务机制（回滚） Mysql的事务机制（transaction） MySQL 事务主要用于处理操作量大，复杂度高的数据。数据库操作语句构成事务。在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。事务一般用来管理 insert,update,de...
C++类学习笔记——C++类成员访问
qq_55904031的博客
08-29 4568
文章目录前言一、对象成员选择运算符 (点)二、C语言和C++中对象成员选择运算符使用方法三、C++访问说明符总结 前言 此文章为初学者为巩固知识创作，大佬轻喷。 上期简单介绍了C++类的声明和类成员，这期简单介绍C++类成员的访问 以下是本篇文章正文内容，下面案例可供参考 一、对象成员选择运算符 (点) 学过C语言的都知道struct（结构体）创建出来的对象可以通过对象成员选择运算符(.)来访问C语言结构体内部成员 二、C语言和C++中对象成员选择运算符使用方法 废话不多说，直接代码： struct S
2021-08-13c++——类之操作符重载
weixin_51187533的博客
08-14 277
+号重载 1）成员函数重载 如果要返回Person类，构造Person的时候就一定要赋初始值。 如果不赋予初始值，就一定要有默认初始值，因为提供了含参构造函数，编译器就不会再提供默认构造函数了。 #include<iostream> #include<string> using namespace std; class Person{ public: int m_age; int m_money; Person(int a = 0,int b = 0
c++ 常用buffer实现
The Coding World
10-26 4679
1、一个buffer缓存简单实现 #include <cstdio> #include <cstring> #include <stdlib.h> #include <malloc.h> class Buffer { public: Buffer() { m_buf = (char *)malloc(m_incr...
算法题递归函数int mystrlen(char *buf, int N)是用来实现统计字符串中第一个空字符前面的字符长度。
蔡松豆的博客
05-16 658
举例来说char buf[] = { 'a', 'b', 'c', 'd', 'e', 'f', '\0', 'x', 'y', 'z' }; 字符串buf[]，当输入N=10,或者20时输出6，N=3或者5时输出3或者5； 下面是具体算法#include<iostream> using namespace std; int mystrlen(char *buf, int N) { if
C/C++编程笔记：C语言字符串比较函数，超详细，值得收藏！
致力于C语言C++知识分享！
06-05 6188
void *memset(void *dest, int c, size_t count); 将dest前面count个字符置为字符c. 返回dest的值. void *memmove(void *dest, const void *src, size_t count); 从src复制count字节的字符到dest. 如果src和dest出现重叠, 函数会自动处理. 返回dest的值. void *memcpy(void *dest, const void *src, size_...
java intbuffer用法_基于IntBuffer类的基本用法(详解)
weixin_39793638的博客
03-06 939
package com.ietree.basicskill.socket.basic.nio;import java.nio.IntBuffer;/*** Created by Administrator on 2017/5/25.*/public class BufferTest {public static void main(String[] args) {// 1 基本操作/*//创建指定...
将int数字存到char buf中
hpclinux的专栏
04-27 2267
将int数字存到char buf中 例如: 将数字2018存到char buf[2]中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值