C++,,

城南小陌又逢春 ，只见梅花不见人。

 #include 
  using namespace std;
   
  int main(int argc, char *argv[])
  {
      int a;
      double b;
      char s[100];
 
      cin>>a>>b>>s;
      cout<<"a="<

普通构造：默认普通构造，没有参数返回值。

拷贝构造：分为浅拷贝，深拷贝

移动构造：编译时需要加入连接-fno-elide-constructors

代码如下

#include 
#include
using namespace std;

class demo{
    public:
        //重写构造
        demo(char *q=nullptr)
        {
            str=new char[strlen("hello")+1];
            strcpy(str,q);
            cout<<"succesful x"<strlen(str)-1)
        {
            printf("erron");
        }
       //str[n]=str[n];
        return str[n];
}
void demo::set(void)
{
    char buf[32]={0};
    printf("plead input n");
    fgets(buf,sizeof(buf),stdin);
    printf("%ldn",strlen(buf));
    if(strlen(buf)>strlen(str))
    {
        delete str;
        str=new char[strlen(buf)+1];
        strncpy(str,buf,strlen(buf)-1);
        printf("change str:%s n",str);
    }
    if(strlen(buf) 
using namespace <>; 
名词空间,把内域变成全局，
 
2022 7.15 
析构函数 
对象销毁时自动调用函数，它可以显示调用
 
~类名（void）
 
注意：1.当存在移动构造时，需要在释放空间之前判断是否是临时变量
               如果时临时变量那么就不释放空间
               2.使用析构显示调用时需要注意重复释放的问题
 
#include 
#include 
using namespace std;

class String{
	
	public:
		//普通构造
		String(const char*p)
		{
			
			cout<<"normal"< len)
			{
				//p大于原来的空间，应该重新开辟一个空间
				delete []addr;
				addr = new char[strlen(p)+1];
				
				strcpy(addr, p);
				len =  strlen(p);
			}
			else
			{
				strcpy(addr, p);
				len =  strlen(p);
			}
		}
		
		void append(const char* p)
		{
			char buf[len+1];    //存储原始数据
			strcpy(buf, addr);
			delete []addr;
			addr = new char[len+strlen(p)+1];
			
			strcpy(addr, buf);
			strcat(addr, p);
			len += strlen(p); 
		}
	private:
		char *addr;
		int len;
};

void test()
{
    char buf[100] = "hello";
    String A = buf;

}

int main()
{
    test();
    while(1);
}
 
关键字  
static 
    1.修饰变量
                 1.全局变量，生命周期不变，作用域被限制在本文件
                 2.局部变量， 延长声明周期到程序结束，作用域不
 
    2.修饰函数
                  声明周期不变，作用域限制在本文件
           
     3.修饰类相关
                  特点：静态成员，不和具体对象关联，没有对象生成静态成员也存在
                       静态成员不属于类，多个对象公用一个静态成员
                       静态成员使用之前必须初始化 类型+类名::变量名=n;
          
 
             
 const        
        

         1.const修饰成员变量
             1.修饰的变量不能被更改,const修饰的变量需要初始化
             2.const修饰的成员变量，必须使用初始化列表进行初始化
             3.非const成员函数可以访问，const成员变量
             初始化列表
             1.可以初始化const修饰的变量，也可以初始化非const修饰的变量
                demo(int n, char c , int *p) 
 
              :a(n),ch(c),b{p[0], p[1], p[2]}
 
               {}
 
 //初始化列表格式，分别对int，char，数组，进行的初始化
           
   
          
         2.const修饰函数
             格式： 返回值 函数名（）const;
             1.const修饰的函数可以访问非const成员
             2.const修饰的函数可以访问const成员
             3.函数内部不能出现修改成员变量值的逻辑出现
             
         
         3.const修饰类
             const修饰的对象，只能调用对象的const修饰的成员函数
         
 
       

                
        
        

  
    
      
        
      
      
        
          暑期编程PK赛
          
        
        得CSDN机械键盘等精美礼品！