<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[weixin_44018317的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/weixin_44018317</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; weixin_44018317]]></copyright><item><title><![CDATA[理解类和对象]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112973986</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112973986</guid><author>weixin_44018317</author><pubDate>Thu, 21 Jan 2021 22:39:16 +0800</pubDate><description><![CDATA[所以简单地总结：类就是图纸，而对象就是根据图纸建造的实体（例如房子）
封装：把属性集中在一个设计里
封装性：体现在不具有访问属性，访问限定符private和protected体现了类具有封装性
对象的存储

对于同一个类实例化的不同对象来说，成员变量时对象私有的，成员方法时所有对象共享的
那么这是怎样实现的呢？
编译器对于类的编译顺序
1）属性（成员变量）
2）方法（成员函数）的原型
3）对成员函数进行改写（添加this指针（[类名] * const this））
this 指针指向对象，通过this指..]]></description><category></category></item><item><title><![CDATA[namespace 命名空间作用域]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848626</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848626</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:48:17 +0800</pubDate><description><![CDATA[C中只有 全局作用域 和  局部作用域
C++中为解决命名冲突，提出这么一个概念
namespace TL13
{
    int a = 10;
    int b = 20;
    int Sum(int a,int b)
    {
        return 0;
    }
}

使用方法：
TL13::sum(10,20);//使用域名
using TL13::sum;//using声明，把声明后的符号暴露在当前using声明所在作用域
using namespace TL13;//usin]]></description><category></category></item><item><title><![CDATA[new与malloc，delete与free区别]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848602</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848602</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:47:40 +0800</pubDate><description><![CDATA[malloc 只开辟空间   new  不仅开辟空间，系统还会调用构造函数
free   只收回空间    delete 先调用析构函数 再收回空间


new / delete 是关键字或运算符，可以重载
malloc / free 是函数


new返回值类型是安全的，不需要强转;大小由系统计算
malloc返回值类型不安全，需要强转;大小需要使用者计算
void* malloc(size_t size);//malloc函数原型
void free(void* ptr);//free函数原型


..]]></description><category></category></item><item><title><![CDATA[C和C++的相互调用]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848573</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848573</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:46:36 +0800</pubDate><description><![CDATA[C++中调用C代码
当编译器编译C++文件时，会优先选择cpp的编译方式
而C代码应该用C的编译方式编译
所以用以下处理方式
#ifdef __cplusplus
extern "C"{
#endif
    
    
    C代码
        
        
#ifdef __cplusplus
}
#endif

C中调用C++代码
//C++源文件可修改
//用extern "C"
//C++源文件不可修改
//加中间层
//写一个接口，用C语言的方式编译，接口中调用C++函数
int a]]></description><category></category></item><item><title><![CDATA[inline函数]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848550</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848550</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:45:25 +0800</pubDate><description><![CDATA[inline函数  在编译阶在调用点直接代码展开
不生成符号，仅文件内可见
inline函数与宏的区别：
​	inline函数在编译阶段 有类检查和安全检查   安全
​	宏  在预编译阶段  直接进行文本替换   不安全
inline函数和static修饰的函数有什么区别：
​	inline直接代码展开，没有开栈清栈开销
​	static 有开栈清栈开销  生成符号 local属性  只在本文件可见
因为没有有开栈清栈开销，所以效率高，那为什么不把所有函数设为inline函数呢
inline缺陷：以代码膨]]></description><category></category></item><item><title><![CDATA[函数重载]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848475</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848475</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:44:33 +0800</pubDate><description><![CDATA[C语言中：不能进行函数重载
C++中：可以进行函数重载
这与函数符号生成规则有关：
C：只和函数名称有关
C++ ：与函数原型有关
函数重载
​	1.函数返回值类型不同     不够成重载   因为函数调用时会产生二义性
​	2.函数名称不同                不够成重载
​	3.形参列表
​		1）形参类型不同   构成
​		2）形参个数不同   构成
​		3）形参顺序不同   构成
函数重载三要素：1.同名2.不同参3.同作用域（源于就近原则）
重载决议过程：精确匹配==&gt;隐式转换]]></description><category></category></item><item><title><![CDATA[函数默认值]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848372</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/112848372</guid><author>weixin_44018317</author><pubDate>Tue, 19 Jan 2021 17:41:26 +0800</pubDate><description><![CDATA[函数默认值
概念：函数设计过程中给予形参默认值，没有实参的话，有默认值
函数默认值赋给规则：
1.函数的默认值自右向左赋予，
​	函数调用过程，实参入栈顺序自右向左；
​	实参与形参匹配，自左向右
2.默认值不能重复赋予
3.默认值一般设在声明上
​	若声明与定义分开，默认值在定义上
​	调用点又在定义点之前，会导致默认值会失效

...]]></description><category></category></item><item><title><![CDATA[第一篇：网络分层模型]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/105968152</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/105968152</guid><author>weixin_44018317</author><pubDate>Thu, 07 May 2020 11:32:20 +0800</pubDate><description><![CDATA[**
为什么要进行网络层次划分
**
首先，网络中最重要的就是数据交换。那么，为进行网络中的数据交换而建立的规则、标准或约定称为网络协议。
网络通信中存在各种各样的问题，有不同的规则，如果我们只用一种协议来规定，那么相互之间势必会产生影响，所以采用分层划分的结构。
分层划分带来的好处：既能规定不同层的完成的功能，又能实现层与层之间的改动而不相互影响
OSI七层模型与TCP/IP五层协议

我们这里...]]></description><category></category></item><item><title><![CDATA[动态内存定义数组]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102975326</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102975326</guid><author>weixin_44018317</author><pubDate>Fri, 08 Nov 2019 16:51:43 +0800</pubDate><description><![CDATA[char a[3]="cs";

这样，我们定义了一个定长的数组。但有时我们需要根据变量来定义数组，这时，我们就要用到动态内存来定义数组。
（这里，我们要知道另外的知识，定义一个定长的数组时，是在栈中申请内存，而用动态内存来定义数组时，是在堆中申请的，两者除了在大小上有区别（栈在1M左右 / 堆在1.2G左右），栈中申请的内存在函数结束后会自动释放，而在堆中申请的内存需要自己去释放。所以在申请大内...]]></description><category></category></item><item><title><![CDATA[递归的实现和内存问题]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102974394</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102974394</guid><author>weixin_44018317</author><pubDate>Fri, 08 Nov 2019 15:53:05 +0800</pubDate><description><![CDATA[如图，有这样一个使用递归的Age函数。
当调用这个函数时，在栈中为它分配了一块内存，实际就是为变量n分配了一块内存，因为还没有到达边界值，所以会一直调用自己，那么就会一直产生新的变量，又要为新的变量分配内存，而不会覆盖在一开始的内存上。
当返回一个值一后，函数才意味着执行完，内存才会被释放，也就是说，如图，对递归来讲，只有执行到边界时，才开始返回值，当数据很大时，这需要大量的内存，也会消耗相对较...]]></description><category></category></item><item><title><![CDATA[对二维数组名的理解]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102973934</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102973934</guid><author>weixin_44018317</author><pubDate>Fri, 08 Nov 2019 15:27:00 +0800</pubDate><description><![CDATA[int arr[8][6]={0}
数据类型




arr : 第0行首地址（代表一整行）
int(*p)[6]


arr+i ：第i行首地址（代表一整行）
int (*p)[6]


把首地址转化为首元素地址 ：加“ * ”:  *(arr+i)  /arr[i]
int *p


得到某个元素的地址： *(arr+i)+n  --&gt; &amp;arr[i][n]
int *p...]]></description><category></category></item><item><title><![CDATA[自加自减符]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102650059</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102650059</guid><author>weixin_44018317</author><pubDate>Sun, 20 Oct 2019 16:16:42 +0800</pubDate><description><![CDATA[先看一看i++和++i  :  ++i表达式的结果是直接进行加“1”，返回的是i这个变量本身，而i++是先把i的值
赋给一个临时变量tmp,再对i加“1”，而表达式的值返回的是临时变量的值。
综上：++i可以被作为一个左值进行赋值，而i++返回的是一个已经消失的临时变量，那么临时变量是无法被赋值的，
所以无法成为左值只能作为右值。


与指针：



int a[]={1,3,6,43,78}...]]></description><category></category></item><item><title><![CDATA[不定时总结 2]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102615417</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102615417</guid><author>weixin_44018317</author><pubDate>Thu, 17 Oct 2019 21:21:40 +0800</pubDate><description><![CDATA[关于  宏：只是单纯的字符替换，不要强加逻辑。

	#define M(x,y,z) x*y+z
	int main()
	{
		int a=2,b=3,c=4;
		printf("%d",M(a+b,b+c,c+a));//  a+b*b+c+a
		return 0;
	}

2.位运算符只能用在整型数据中。
3.用下标访问字符串。

...]]></description><category></category></item><item><title><![CDATA[（面试题）一类题：给出一个未知进制的等式，求其进制]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102615363</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102615363</guid><author>weixin_44018317</author><pubDate>Thu, 17 Oct 2019 21:18:13 +0800</pubDate><description><![CDATA[假设在进制下，下面的等式成立，567*456=150216，n的值是（）
A. 9         B.10        C.12        D.18
解：


]]></description><category></category></item><item><title><![CDATA[折半查找（二分法）]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102614638</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102614638</guid><author>weixin_44018317</author><pubDate>Thu, 17 Oct 2019 20:44:18 +0800</pubDate><description><![CDATA[有15个数字由大到小顺序存放在一个数组中，输入一个数字，要求用折半查找的方法找出该数是数组的第几个元素的值。如果该数不在数组中，则输出“无此数”。
#include&lt;stdio.h&gt;

int fun(int *arr,int len,int key)
{
	int max=len-1;
	int mid;
	int low=0;
	while(low&lt;=max)
	{
		mi...]]></description><category></category></item><item><title><![CDATA[翻转数列（含腾讯笔试题）]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102613624</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102613624</guid><author>weixin_44018317</author><pubDate>Thu, 17 Oct 2019 20:00:40 +0800</pubDate><description><![CDATA[小Q定义了一种数列称为翻转数列:
给定整数n和m, 满足n能被2m整除。对于一串连续递增整数数列1, 2, 3, 4…, 每隔m个符号翻转一次, 最初符号为’-’;。
例如n = 8, m = 2, 数列就是: -1, -2, +3, +4, -5, -6, +7, +8.
而n = 4, m = 1, 数列就是: -1, +2, -3, + 4.
小Q现在希望你能帮他算算前n项和为多少。
输入描...]]></description><category></category></item><item><title><![CDATA[不定时总结（1）]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102573788</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102573788</guid><author>weixin_44018317</author><pubDate>Tue, 15 Oct 2019 20:31:43 +0800</pubDate><description><![CDATA[#include&lt;stdio.h&gt;

int main()
{
	int a=4321;
	char b[]="dhfguh";
	printf("%d\n",printf("%d",a));
	printf("%d\n",printf("%s",b));
	return 0;
}


printf错误使用时会返回变量的长度。
#include&lt;stdio.h&gt;

int ...]]></description><category></category></item><item><title><![CDATA[最大公约数的求解（初次接触递归算法）（辗转相除法）]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102572576</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102572576</guid><author>weixin_44018317</author><pubDate>Tue, 15 Oct 2019 18:56:04 +0800</pubDate><description><![CDATA[辗转相除法：
#include&lt;stdio.h&gt;

int fun(int n,int m)
{
	int tmp;
	if(n&lt;m)
	{
		tmp=n;
		n=m;
		m=tmp;
	}
	while(m&gt;0)
	{
		tmp=n%m;
		n=m;
		m=tmp;
	}
	return n;
}
int main()
{
	printf("%d",fun(1...]]></description><category></category></item><item><title><![CDATA[浮点数的误差问题  1（C语言）]]></title><link>https://blog.youkuaiyun.com/weixin_44018317/article/details/102571150</link><guid>https://blog.youkuaiyun.com/weixin_44018317/article/details/102571150</guid><author>weixin_44018317</author><pubDate>Tue, 15 Oct 2019 18:16:05 +0800</pubDate><description><![CDATA[先来看一段程序：
int main()
{
	double n=0.01;
	double tmp=0;
	for(int i=0;i&lt;40000000;i++)
	{
		tmp+=n;
	}
	printf("%f",tmp);
	return 0;
}


从这段程序中可以明显看出编译结果产生了误差，所以浮点数的计算中是存在误差的。
#include&lt;stdio.h&gt;

i...]]></description><category></category></item></channel></rss>