c++学习中遇到的知识点

最新推荐文章于 2023-09-05 19:59:19 发布

韩帅平

最新推荐文章于 2023-09-05 19:59:19 发布

阅读量455

点赞数

本文链接：https://blog.csdn.net/youmatterhsp/article/details/79717496

版权

1. 对于const重载［］运算符时，有没有const区别是:有const只读。没有const读写都可以。c++中，能作为函数重载判断依据的是：const。参数个数。参数类型。
#include<iostream>
#include<string>
using namespace std;

void Test(int a,int b){}//①
//int Test(int a,int b){}//②
//报错，显示①和②两个函数重定义。

void Test(int a,float b){}//③
//①和③构成重载--参数的类型不同。

void Test(int a,int b,int c){}//④
//①和④构成重载--参数的个数不同。

//void Test(const int a,int b){}//⑤
//报错。显示重定义。

void Test(int& a,int b){}//⑥
void Test(const int &a,int b){}
//①和⑥构成重载--因为参数int& a和int a可以作为重载依据。

void Test(int* a,int b){}//⑦
void Test(const int *a,int b){}
//道理同上。

int main()
{

return 0;
}

2. 关于const函数的一些内容：

c++的const函数特点：

1. 不能在const函数中修改所在类的对象的数据，因为const函数中的*this是常量，同样只能访问const函数；

2. const函数中只能调用其他的const函数，不能调用非const函数，因为对象调用函数是需要传递对象自己，const函数中的*this是常量，非const函数中的*this是变量，因此不可以调用(除非去除*this的const属性)；

Note:使用const_cast后，可以在const函数中调用非const函数的

3. const函数与同名的非const函数是重载函数；

4. const对象只能调用const函数 ，但是非const对象可以调用const函数。

3. static变量：程序再次调用时static变量的值不会重新初始化，而是在上一次退出时的基础上继续执行

4. assert：在现实世界中，我们脑袋时刻都在判断对与错，对的事情我们会继续深入下去，而错的事情我们会马上停止，那么在编程开发中我们如何赋予程序这种判断事物对错的能力呢？其中一个方案就可以使用断言assert，我们最常用的地方就是在函数中检查形参的数据合法性。

5. sizeof 和 strlen 对字符串的处理不同之处， sizeof 求出字符串的字符个数，包括结尾符。 Strlen 求出字符串的实际字符，不包括结尾符。

6. 关于以下代码

myClass::foo()

{

delete this;

}

void func()

{

myClass *a = newmyClass();

a->foo();

}

正确答案: B 你的答案: C (错误)

它会引起栈溢出

都不正确

它不能编译

它会引起段错误

出处：http://blog.sina.com.cn/s/blog_4b4cf2af0100ywgv.html

在类的成员函数中能不能调用delete this？答案是肯定的，能调用，而且很多老一点的库都有这种代码。假设这个成员函数名字叫release，而delete this就在这个release方法中被调用，那么这个对象在调用release方法后，还能进行其他操作，如调用该对象的其他方法么？答案仍然是肯定的，调用release之后还能调用其他的方法，但是有个前提：被调用的方法不涉及这个对象的数据成员和虚函数。说到这里，相信大家都能明白为什么会这样了。

根本原因在于delete操作符的功能和类对象的内存模型。当一个类对象声明时，系统会为其分配内存空间。在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。

为什么是不可预期的问题？delete this之后不是释放了类对象的内存空间了么，那么这段内存应该已经还给系统，不再属于这个进程。照这个逻辑来看，应该发生指针错误，无访问权限之类的令系统崩溃的问题才对啊？这个问题牵涉到操作系统的内存管理策略。delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，可能是缓冲或者其他什么原因，导致这段内存空间暂时并没有被系统收回。此时这段内存是可以访问的，你可以加上100，加上200，但是其中的值却是不确定的。当你获取数据成员，可能得到的是一串很长的未初始化的随机数；访问虚函数表，指针无效的可能性非常高，造成系统崩溃。

大致明白在成员函数中调用delete this会发生什么之后，再来看看另一个问题，如果在类的析构函数中调用delete this，会发生什么？实验告诉我们，会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存” (来自effective c++)。显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。没有函数返回值类型，

第二种解释： a 是一个类指针，指向一个动态分配的类；

foo是该类的成员函数，而成员函数具有一个隐含形参：一个指向调用该函数的类对象的指针，即this指针；

当通过指针a 调用函数foo 时，this 指针就是 a指针了，所以deletethis 就等于 delete a，也就是释放掉动态分配的内存。

第三种解释：可以看到，foo中delete的作用就是析构的作用。类似于手动的析构，所以在程序结束后就不会在调用类默认的析构函数，故不会发生错误。

7. classCBuffer

{

char* m_pBuffer;

intm_size;

public:

CBuffer()

{

m_pBuffer=NULL;

}

~CBuffer()

{

Free();

}

voidAllocte(intsize) （1） {

m_size=size;

m_pBuffer= newchar[size];

}

private:

voidFree()

{

if(m_pBuffer!=NULL)(2)

{

delete[]m_pBuffer;

m_pBuffer=NULL;

}

public:

voidSaveString(constchar* pText) const(3)

{

strcpy(m_pBuffer,pText); (4)

}

char*GetBuffer() const

{

returnm_pBuffer;

}

};

voidmain (intargc, char* argv[])

{

CBuffer buffer1;

buffer1.SaveString("Microsoft");

printf(buffer1.GetBuffer());

}可能有问题的是：

(1) 分配内存时, 未检测m_pBuffer是否为空, 容易造成内存泄露;

(3) 常成员函数不应该对数据成员做出修改, 虽然可以修改指针数据成员指向的数据, 但原则上不应该这么做;

(4) 字符串拷贝时, 未检测是否有足够空间, 可能造成程序崩溃。

8. 关于unsigned int a=1和signed int b=-3：

有符号数和无符号数进行比较运算时（==，<,>,<=,>=）,有符号数隐式转换成了无符号数（即底层的补码不变，但是此数从有符号数变成了无符号数），比如上面 (a+b)>0这个比较运算，a+b=-2。此数进行比较运算时，被当成了无符号数，它远远大于0

      unsigned int类型，即无符号整型;
整型的每一种都有无符号（unsigned）和有符号（signed）两种类型，在默认情况下声明的整型变量都是有符号的类型，如果需声明无符号类型的话就需要在类型前加上unsigned，只有unsigned时，表示unsigned int;
现在的系统中，int一般都占4个字节，32位，表示的数组范围是-2147483648~2147483647，而无符号整型（unsigned int）不表示负数，所以表示的整数是有符号的整数的2倍，即0~4294967295。

9. C++里面如何声明const void f(void)函数为C程序中的库函数。

extern“c”；原因：

void f(void)用c++ compiler来编译，在产生的obj文件中的名字变成了

$f@@@_@0

void f(voi)用c compiler编译，obj中变成了

_f

如果是extern "C" void f(void)，仍然用c++编译器编译，变成

_f

所以extern "C"是强迫c++编译器对函数名进行修饰的时候采用c命名约定。

这样，在c++写的程序中就可以使用已经用c编译器编译好的obj或者lib了。

10. 在c++中怎样保留小数位：

#include<iostream>

#include<iomanip>

using namespacestd;

#include<iomanip> //要用到格式控制符

int main()

{

double amount = 22.0/7;

cout <<fixed<<setprecision(2)<<amount <<endl;

}

11. while(scanf("%d%d",&n,&m),n,m)的含义：其功能是循环从输入流读取m和n，直到遇到n=0且m=0的时候为止。

12. memset函数用法详解：

_memset

int a[100]; memset(a, MAX,sizeof(a));就是将a数组全部赋值为MAX,现在才知道他的填充是以字节为单位,一般用于对字符型变量的初值进行赋值.

编辑

memset是计算机中C/C++语言函数。将s所指向的某一块内存中的前n个字节的内容全部设置为ch指定的ASCII值，第一个值为指定的内存地址，块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工作，其返回值为指向s的指针。

中文名

memset函数

外文名

memset

别称

初始化函数

表达式

memset(void *s,int ch,size_t n);

应用学科

计算机

适用领域范围

C/C++

头文件

<memory.h>或<string.h>

函数

void *memset

原型

(void *s,int ch,size_t n);

函数介绍

编辑

void *memset(void *s, int ch, size_t n);

函数解释：将s中当前位置后面的n个字节（typedef unsigned int size_t ）用 ch 替换并返回s 。

memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法^[1] 。

常见错误

编辑

第一：memset函数按字节对内存块进行初始化，所以不能用它将int数组初始化为0和-1之外的其他值（除非该值高字节和低字节相同）。

第二：memset(void *s, int ch,size_tn);中key实际范围应该在0~~255，因为该函数只能取ch的后八位赋值给你所输入的范围的每个字节，比如int a[5]赋值memset（a,-1,sizeof(int)*5）与memset（a,511,sizeof(int )*5）所赋值的结果是一样的都为-1；因为-1的二进制码为（1111111111111111 11111111 11111111）而511的二进制码为（00000000 00000000 0000000111111111）后八位都为（11111111)，所以数组中每个字节，如a[0]含四个字节都被赋值为（11111111），其结果为a[0]（1111111111111111 11111111 11111111），及a[0]=-1，因此无论ch多大只有后八位二进制有效，而八位二进制^[2] 的范围（0~255）YKQ改。而对字符数组操作时则取后八位赋值给字符数组，其八位值作为ASCII^[3] 码。

第三：搞反了 ch 和 n 的位置.

一定要记住如果要把一个char a[20]清零，一定是memset(a,0,20*sizeof(char));

而不是 memset(a,20*sizeof(char),0);

第四：过度使用memset，我想这些程序员可能有某种心理阴影，他们惧怕未经初始化的内存，所以他们会写出这样的代码：

char buffer[4];

memset(buffer,0,sizeof(char)*4);

strcpy(buffer,"123");

//"123"中最后隐藏的'\0'占一位，总长4位。

这里的memset是多余的. 因为这块内存马上就被全部覆盖，清零没有意义.

另：以下情况并不多余，因某些编译器分配空间时，内存中默认值并不为0：

char buffer[20];

memset(buffer,0,sizeof(char)*20);

memcpy(buffer,"123",3);

//这一条的memset并不多余，memcpy并没把buffer全部覆盖，如果没有memset，

//用printf打印buffer会有乱码甚至会出现段错误。

//如果此处是strcpy(buffer,"123");便不用memset,

//strcpy虽然不会覆盖buffer但是会拷贝字符串结束符

第五：其实这个错误严格来讲不能算用错memset，但是它经常在使用memset的场合出现

int some_func(struct something *a)

{

…

memset(a,0,sizeof(a));

…

}

这里错误的原因是VC函数传参过程中的指针降级，导致sizeof(a)，返回的是一个something*指针类型大小的的字节数，如果是32位，就是4字节。

常见问题

编辑

问：为何要用memset置零?memset(&Address,0,sizeof(Address））；经常看到这样的用法，其实不用的话，分配数据的时候，剩余的空间也会置零的。

答：1.如果不清空，可能会在测试当中出现野值。你做下面的试验看看结果()

#include <iostream>

#include <string.h>

#include <afx.h>

using namespace std;

int main()

{

char buf[5];

CString str;

CString str1;

CString str2;

memset(buf,0,sizeof(buf));

for(int i=0;i<5;i++)

{

str.Format("%d",buf[i]);

str1+=str;

}

str2.Format("%d",str1);

cout<<str2<<endl;

system("pause");

return 0;

}

这样写，有没有memset，输出都是一样

⒉其实不然！特别是对于字符指针类型的，剩余的部分通常是不会为0的，不妨作一个试验，定义一个字符数组，并输入一串字符，如果不用memset实现清零，使用MessageBox显示出来就会有乱码（0表示NULL，如果有，就默认字符结束，不会输出后面的乱码）

问：

如下demo是可以的，能把数组中的元素值都设置成字符1，

#include <iostream>

#include <cstring>

using namespace std;

int main()

{

char a[5];

memset(a,'1',5）;

for(int i=0;i<5;i++)

cout<<a[i]<<"";

system("pause");

return 0;

}

而，如下程序想把数组中的元素值设置成1，却是不可行的

#include <iostream>

#include <cstring>

#include <windows.h>

using namespace std;

int main()

{

int a[5];

memset(a,1,20）;

//也等价于memset(a,1,sizeof(a));.

for(int i=0;i<5;i++)

cout<<a[i]<<"";

system("pause");

return 0;

}

问题是：

1.第一个程序为什么可以，而第二个不行？

因为第一个程序的数组a是字符型的，字符型占据内存大小是1Byte，而memset函数也是以字节为单位进行赋值的，所以你输出没有问题。而第二个程序a是整型的，使用memset还是按字节赋值，这样赋值完以后，每个数组元素的值实际上是0x01010101即十进制的16843009。

如果用memset(a,1,20)，就是对a指向的内存的20个字节进行赋值，每个都用数1去填充，转为二进制后，1就是00000001，占一个字节。一个int元素是4字节，合一起是00000001,0000 0001,0000 0001,0000 0001，转化成十六进制就是0x01010101，就等于16843009，就完成了对一个int元素的赋值了。

2.不想要用for，或是while循环来初始化int a[5]；能做到吗？（有没有一个像memset()这样的函数初始化）

这样是比较麻烦的，memset是最快捷的方法。

程序范例

编辑

#include <string.h>

#include <stdio.h>

#include <memory.h>

int main(void)

{

char buffer[]="Helloworld\n";

printf("Buffer before memset:%s\n",buffer);

memset(buffer,'*',strlen(buffer));

printf("Buffer after memset:%s\n",buffer);

return 0;

}

输出结果：

Buffer before memset:Helloworld

Buffer after memset:***********

编译平台：

MicrosoftVisual C++6.0

也不一定就是把内容全部设置为ch指定的ASCⅡ值，而且该处的ch可为int或者其他类型，并不一定要是char类型。例如下面这样：

int array[5]={1,4,3,5,2};

for(int i=0;i<5;i++)

cout<<array[i]<<"";

cout<<endl;

memset(array,0,5*sizeof(int));

for(int k=0;k<5;k++)

cout<<array[k]<<"";

cout<<endl;

输出的结果就是：

1 2	`14352` `00000`

后面的表大小的参数是以字节为单位，所以，对于int或其他的就并不是都乘默认的1（字符型）了。而且不同的机器上int的大小也可能不同，所以最好用sizeof()。

要注意的是，memset是对字节进行操作，

所以上述程序如果改为

int array[5]={1,4,3,5,2};

for(int i=0;i<5;i++)

cout<<array[i]<<"";

cout<<endl;

memset(array,1,5*sizeof(int));//注意这里与上面的程序不同

for(int k=0;k<5;k++)

cout<<array[k]<<"";

cout<<endl;

输出的结果就是：

1 2	`14352` `1684300916843009168430091684300916843009`

为什么呢？

因为memset是以字节为单位就是对array指向的内存的4个字节进行赋值，字节，合一起就是

1	`00000001000000010000000100000001`

就等于16843009，就完成了对一个INT元素的赋值了。

所以用memset对非字符型数组赋初值是不可取的！

例如有一个结构体Some x，可以这样清零：

1	`memset(&x,0,sizeof(Some));`

如果是一个结构体的数组Some x[10]，可以这样：

1	`memset(x,0,sizeof(Some)*10）；`

memset函数详细说明

1.void *memset(void *s,int c,size_tn)

总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值 c。

2.例子

int main()

{

char *s="GoldenGlobalView";

clrscr();

memset(s,'G',6);//这里没有问题，可以编译运行，在这里将右括号和分号变成了中文输入法

//单步运行到这里会提示内存访问冲突

//肯定会访问冲突，s指向的是不可写空间。

printf("%s",s);

getchar();

return 0;

}

【以上例子出现内存访问冲突应该是因为s被当做常量放入程序存储空间，如果修改为 char s[]="GoldenGlobal View";则没有问题了。】

【应该是没有问题的，字符串指针一样可以，并不是只读内存，可以正常运行】

【此实例可以正常编译运行，并不需要char s[]】

【memset(s,'G',6)这样是存在内存访问冲突的，因为s为常量字符串，不能修改的】

【的确需要改为char s[],否则s不能修改】

3.memset() 函数常用于内存空间初始化。如：

1 2	`char` `str[100];` `memset(str,0,100）；`

4.memset()的深刻内涵：用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘memset(a,'\0',sizeof(a));

5.补充：一点技巧

memset可以方便的清空一个结构类型的变量或数组。

如：

struct sample_struct

{

char csName[16];

int iSeq;

int iType;

};

对于变量

1	`struct` `sample_struct stTest;`

一般情况下，清空stTest的方法：

stTest.csName[0]={'\0'};

stTest.iSeq=0;

stTest.iType=0;

用memset就非常方便：

1	`memset(&stTest,0,sizeof(sample_struct));`

如果是数组：

1	`structsample_struct TEST[10];`

则

1	`memset(TEST,0,sizeof(structsample_struct)*10）；`

另外：

如果结构体中有数组的话还是需要对数组单独进行初始化处理的。

13.定义二维数组:int a[i][j];
定义一个指针:int *p;
p=a;

p+i:是第i行的首地址.
*(p+i)是第i行第0列元素的地址.
*(p+i)+j是第i行第j列元素的地址.
*(*(p+i)+j)是第i行第j列元素所对应的值.

14.在C语言中，double、long、unsigned、int、char类型数据所占字节数

http://blog.csdn.net/lyl0625/article/details/7350045

============================

实在记不住，贴下来：

和机器字长及编译器有关系：

所以，int，long int，short int的宽度都可能随编译器而异。但有几条铁定的原则（ANSI/ISO制订的）：

1 sizeof(short int)<=sizeof(int)

2 sizeof(int)<=sizeof(long int)

3 short int至少应为16位（2字节）

4 long int至少应为32位。

unsigned 是无符号的意思。

例如：
16位编译器

char ：1个字节

char*(即指针变量): 2个字节

short int : 2个字节

int： 2个字节

unsigned int : 2个字节

float: 4个字节

double: 8个字节

long: 4个字节

long long: 8个字节

unsigned long: 4个字节

32位编译器（看这里就行了，与16位机，64位机比较，粗体type为不同的，其余的都是相同）

char：1个字节

char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）（16位机，32位机，64位机各不相同）

short int : 2个字节

int： 4个字节（16位机是2B，32位&64位是4B）

unsigned int : 4个字节（16位机是2B,32位&64位是4B）

float: 4个字节

double: 8个字节

long: 4个字节（16位&32位是4B，64位是8B）

long long: 8个字节

unsigned long: 4个字节（16&32位是4B,64位是8B

64位编译器

char ：1个字节

char*(即指针变量): 8个字节

short int : 2个字节

int： 4个字节

unsigned int : 4个字节

float: 4个字节

double: 8个字节

long: 8个字节

long long: 8个字节

unsigned long: 8个字节

15. feof(tp)函数功能是：测试所指的文件的位置指针是否已达到文件尾，如果已达到文件尾，则函数返回非0值；否则返回0，表示文件未结束。

16.  这两个其实是数字指针和指针数组的区别。我们一个一个来说明:
int *p[3];//定义了一个三维数组，其中的每个元素p[0]、p[1]、p[2]都是指向int变量的指针。
int   (*p)[3];//定义了一个指针，这个指针是指向一个三维数组的。

两者之间的区别和联系可以用一个二维数组来阐述：

int *p[3];//定义p[3]为指针数组
int (*q)[3];//定义q为数组指针

int a[4][3];//定义一个二维数组

p[0]=&a[0][0];//可以取a[4][3]中任意元素的地址给p[3]中的元素赋值
q=a[1];//a[1]其实是一个三维数组，其元素包括a[1][0]，a[1][1]，a[1][2]，所以
           //a[1]就表示这个数组的首地址，这个地址可以用来给q赋值

主函数最后加一句getchar();有什么用啊？

17. 主函数调用结束之后，一个应用程序就算运行完毕，并退出，通常在它运行推出之前，为了给开发者看清楚它的调用运行结果，很多人都会刻意的在末尾添加getchar();目的就是为了在退出之前可以让调用者再输入一个字符，这时候系统的I/O就停留在读入之上，调用者就可以看清输出了。

18. #include <stdio.h>

#include<string.h>

#defineN 12

intmain()

{

char str[] ="clanguage",t;

int i,j,k;

k =strlen(str);

for(i=0;i<=k-2 ;i++,i++)

{

for(j=i+2;j<=k;j+=2)

if(str[i]>str[j] )

{

t= str[i];

str[i]=str[j];

str[j]=t;

}

puts(str);

return 0;

}

韩帅平

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++学习中遇到的知识点

1. 对于const重载［］运算符时，有没有const区别是:有const只读。没有const读写都可以。c++中，能作为函数重载判断依据的是：const。参数个数。参数类型。 #include&lt;iostream&gt;#include&lt;string&gt;using namespace std;void Test(int a,int b){}//①//int Test(int...
复制链接

扫一扫