C/C++语言一些知识

我不是女神ヾ 2022-02-01 00:09 201阅读 0赞

**C++知识**

*  c++的析构函数书上推荐用来释放内存的。  
    eg: ~类名（）\{xxxx delete \[\] text; \}
 *  运算符重载  
    eg: cin >> cout << ，一定是cin 的类的成员函数有 类名： operator>>(); 这样定义，所以才能使用。当然我们可以自定义自己的类的运算符重载。
 *  继承：  
    写法 eg: class Circle: public Shape\{\}; Circle继承Shape类。  
    同时允许父类的指针指向子类的实例 eg: Circle c; Shape \*p=&c;
 *  虚函数（就是多态）  
    在父类中public：  
    virtual void grow();  
    子类中实现public:  
    void grow()\{\};
 *  模板类，其实类似Java泛型 Stack
 *  异常处理try …catch

**C语言的知识**

*  数组的地址情况  
    int b\[\];  
    b代表数组的首地址。  
    &b则是整个数组的地址 b+1!=&b+1
 *  C编译器对的结构体的注意事项

struct Teach{
    	char[40] name;
    	int age;
    }Teach;                  引用就必须得加 struct 关键字  struct Teach t1;不然报错，但是在C++增强了，不会报错，C语言会。
    
    第二种就是
    typedef struct Teacher{
    	char[40] name;
    	int age;
    }Teacher;   				直接 Teacher t2，不会报错。

*  地址值  
    1245024  
    *（（int*）1245024） = 200等价于 p = 1245024;\*p=200;这样做编译器帮忙做成左边那样的。
 *  在方法中定义的变量和参数，在方法结束，栈上的内存都会被析构（类似回收），如果方法返回了一个指针，**这个指针返回的地址还在，但是指向的内存空间失效，如果拿返回的指针操作**，程序就会死掉。

char * meth(){
    char *p = null;
    p = “asdsd”;    	//应用 malloc(sizeof(xx));
    return p;         再使用*P，程序可能会直接运行不了。
    }

*  指针初始化时被定义为NULL, char\*p = NULL, 在释放内存后也得重新置NULL, free( p ),p = NULL.避免野指针的使用
 *  **C语言指针的传递，把传入的指针完成功能后修改**。达到分层的效果。完成接口的模块。  
    间接赋值推论  
    用1级指针形参，去修改0级指针（实参）的值  
    用2级指针形参，去修改1级指针的值。  
    用3级指针形参，去修改2级指针的值。  
    用n级指针形参，去修改n-1级指针的值。
 *  **C语言的字符串以 ‘\\0‘结尾。**  
    字符串在C语言没有这个类型，以字符数组来定的。  
    字符串的内存分配，堆上，栈上，全局区。
 *  几种初始化字符的方法

> 1.char buf\[\] = \{‘s’,’s’,’d’\};  
> 2.char buf\[4\] = \{‘s’,’s’,’s’,’s’\};  
> 3.字符串初始化字符数组 char buf3\[\] = “abcd”; buf3作为字符数组 应该是5个字节，作为字符串4个字节。strlen(buf3) 长度是4. size = sizeof(buf3)则是5.因为’\\0’也占空间。

*  **C语言的字符数组复制的最后一位，需要人为的补充 b\[i\]=’\\0’;** 不然打印b这个字符数组，就是后面乱码。  
    但是数组才需要加’\\0’，char \*p=”asdv”;这编译器自动给最后一位加’\\0’
 *  指针使用的一些错误案例

> 1.  char \*myto = NULL;  
>     copy\_str(from,myto);  
>     myto地址是0，\*myto指向0这块内存空间，0这块地址空间是收到保护的，所以每次程序运行不了。这也是我总是错的原因。  
>     2.在一个函数中，形参被传入后，拿形参指针操作后，形参的地址肯定会被改变，最后想拿形参操作得到刚开始的操作，那么一定是不对的。  
>     3.操纵char \*p = “sdsads”;  
>     不能修改p的地址，因为p指向的内存空间是可读，不可写的。  
>     p指向的内存空间是常量区。  
>     4.getStar(char \* p,char \* a)\{  
>     if(p==NULL)\{  
>     return\}; // 必须提前判断，不然如果传了NULL指针，程序总是运行不了的。  
>     if(\*p！=‘\\0’)； //这就错误了  
>     5.char buf\[3\]=”abc”; //错误了，实际abc后面需要一个’\\0’空间。

*  **Const关键字**  
    const int a;  
    int const b; 这2个一样的。a,b不可变
 *  几个C语言的函数  
    **memset** 设置s中的所有字节为ch, s数组的大小由n给定  
    void \*memset(void \*s, char ch, unsigned n);

程序例: 
    #include <string.h> 
    #include <stdio.h> 
    #include <mem.h> 
    int main(void) 
    { 
       char buffer[] = "Hello world\n"; 
       printf("Buffer before memset: %s\n", buffer); 
       memset(buffer, '*', strlen(buffer) - 1); 
       printf("Buffer after memset:  %s\n", buffer); 
       return 0; 
    }

*  C数组的情况  
    typedef int (MyArrayType)\[5\];  
    MyArrayType myArray; //int myArray\[5\]; 这样也能定义
 *  /**/多维数组的本质 数组指针**  
    //(a+i)代表是**整个**第i行的地址，二级指针 //因为a是数组名，**类型是数组类型**  
    //*(a+i)代表1级指针，第i行首元素的地址 //整个第一行的地址和第一行首元素的地址是重叠的  
    //*(a+i)+j = &a\[i\]\[j\]  
    //*(*(a+i)+j) =a\[i\]\[j\]的值
 *  **通过数组下标和指针操纵字符串**  
    解释： \[\]和*p 取值操作，p\[5\]---->p\[0+5\]------> \* (p+5) 用数组取值，方便人脑的思考，指针取值是编译器帮我们从数组形式到*指针取值。
 *  结构体的定义  
    用类型定义变量的3种方法：

1.struct  Student{
    char name[64];
    int age;
    }s1,s2;    //定义类型的同时，定义变量

2.匿名
    struct 
    {
    char name[64];
    int age;
    }s3,s4;   //匿名类型 定义变量

初始化
    1.定义就赋值
    Teacher t1 = {“aaa”,31,01};

*  介绍2个C语言的函数  
    strcpy()函数和memcpy函数

函数名: strcpy 
    功  能: 串拷贝 
    用  法: char *strcpy(char *str1, char *str2); 
    程序例: 
    
    #include <stdio.h> 
    #include <string.h> 
    
    int main(void) 
     { 
        char string[10]; 
        char *str1 = "abcdefghi"; 
    
        strcpy(string, str1); 
        printf("%s\n", string); 
        return 0; 
     } 
    函数名: memcpy 
    功  能: 从源source中拷贝n个字节到目标destin中 
    用  法: void *memcpy(void *destin, void *source, unsigned n); 
    程序例: 
    
    #include <stdio.h> 
    #include <string.h> 
    int main(void) 
    { 
       char src[] = "******************************"; 
       char dest[] = "abcdefghijlkmnopqrstuvwxyz0123456709"; 
       char *ptr; 
       printf("destination before memcpy: %s\n", dest); 
       ptr = memcpy(dest, src, strlen(src)); 
       if (ptr) 
          printf("destination after memcpy:  %s\n", dest); 
       else 
          printf("memcpy failed\n"); 
       return 0; 
    }