C++ 基础-阿里云开发者社区

一、友元函数

可以访问私有

#include <iostream>//包含了大部分的头文件
using namespace std;//命名空间相当于全局声明std 输出流
class Car //类名
{
    public:  //公有
    friend void Print(Car *sp);//修饰成为友元函数
    void h(int yy)//改变私有变量
    {
    number=yy;
    }
    private://私有数据成员和成员函数
    int H=170;ll身高
    int number=1000;//身价
};
/**
* @brief Print
* param sp对象传参时必须传这个类型的对象
*/
void Print(Car *sp)l/公共访问私有变量
{
   cout<<"身高"<<sp->H<<"CM"<<endl;
   cout<<"身价"<< sp->number <<"万"<<endl;
}
int main()
{
   Car *Pt =new Car(  ;Pt->h( 100000000);Print(Pt);
}
//类的继承，函数多态，函数重载

二、类的嵌套

#include <iostream>//头文件
#include <string.h>
using namespace std;//命名空间
class Animal //动物类型
{
  public:  //公有的
  int a=1000;
  class Dog//
  {
      public:
      int b=999;
  };
};
int main()
{
    Animal sp;
    cout <<sp.a<<endl;
    Animal : :Dog st;//访问Dog必须加上作用域 否则禁止访问
    st.b;//访问嵌套的成员
    cout <<st.b<<endl;
    return 0;
}

带参数的嵌套

#include <iostream>
#include <string>
using namespace std;
class Boy
{
    private :
    public:
      Boy ();
       class Human
       {
        private:
        int height;
        int weight;
        public:
        Human(int height，int weight); //声明构造函数
        ~Human( );
        };
};
Boy : : Human: : Human(int height , int weight) :height(height)，weight(weight)
{
   cout << height ;
}
Boy : : Human : : ~Human()//析构函数
{
}
int main(void)
{
     //Human a;  //Human类作为Boy类下的嵌套类，不能只用该类的类名创建对象
    Boy :: Human a(10,199);//使用类名::嵌套类名对象
来创建嵌套类的对象
}

三、命名空间

封装变量函数

#include <iostream>
#include <string>
using namespace std;//没有命名空间需要加上输出流的作用域
//定义带标签的全局定义
namespace Usart{
   int bound=115200;
   int datalen;
   int TXD;
   int RXD;
   void fun()
   {
     std: : cout<<"12345"<<std : :endl;
   }
}
using namespace Usart; //声明
int main(void)
{
    std:: cout<<Usart: : bound<<std : :endl;
    Usart:: fun();
}
//inline 内联函数自己写的函数有时候会重复嵌套使用，会造成多次重复执行和编译

四、继承和多继承

例子：

换代叠加功能,重写优化

单继承格式：

class 派生类名∶派生方式基类名

{ // 派生类新增的数据成员和成员函数 } ;

多继承：

class 派生类名∶派生方式基类A名，派生方式基类B名，

{ // 派生类新增的数据成员和成员函数 } ;

派生出来的类就可以使用公共函数。。。。。

#include <iostream>//包含了大部分的头文件
using namespace std; //命名空间相当于全局声明std输出流
class Car //基类父类
{
     public:l//公有
     void Cou()
     {
     cout<<"基类函数:"<<"4个轮子"<<endl;
     } 
     private: //私有数据成员和成员函数
     int x=100;
};
class A //基类父类
{
     public: //公有
     void couA() 
     {
        cout<<"A类: "<<"外壳"<<endl;}
     };
//子类派生类
class Car_v10 :public car,public A
{
     public: //公有
     void couV10()
     {
         cout<<"子类函数;"<<"4个轮子+发动机"<<endl;
     }
      private: //私有数据成员和成员函数
};
int main()
{
   Car_v10 *sp= new Car_v10();
   sp->Cou();
   sp->Couv10();
   sp->CouA();
}

私有：

1、私有派生

（1）私有派生类对基类成员的访问

由私有派生得到的派生类，对它的基类的公有成员只能是私有继承，也就是说基类的所有公有成员都只能成为私有派生的私有成员，这些私有成员能够被派生的成员函数访问，但是基类私有成员不能被派生类成员函数访问。

五、函数重载

<< >> 在C语言叫左移右移在C++可以是输入输出也可以是左移右移

意思就是说一个东西多种功能，在C语言函数是不能重名的

函数重载：函数名一样参数根据形参而选择函数使用，函数重载一次后在派生类内不要在次重载

#include <iostream>//包含了大部分的头文件
using namespace std; //命名空间相当于全局声明std 输出流
class Car //基类父类
{
   public://公有
   void Cou()
   {
      cout<<"无参数"<<endl;
   }
   void Cou(int a)
   {
      cout<<"输出整型"<<a<<endl;
   }
void Cou(string a)
{
  cout<<"字符串"<<a<<endl;
}
private: //私有数据成员和成员函数
};
//子类派生类
class Car_v10 :public Car
{
   public: //公有
   void Couv10()
   {
      cout<<"子类函数: "<<"4个轮子+发动机"<<endl;
   }
   private: //私有数据成员和成员函数
};
int main()
{
  Car_v10*sp= new Car_v10();
  sp->Cou();
  sp->Cou( 10);
  sp->Cou("你好");
  sp->CouV10() ;
}

六、函数多态

函数多态作用，调用不同对象对同意函数操作会输出不同结果，为了后续重写，抽象函数

#include <iostream>//包含了大部分的头文件
using namespace std;//命名空间相当于全局声明std 输出流
class Person {
public:
//虚函数
  virtual void BuyTicket(){/*空*/} 
protected:
  string _name;
};
class student : public Person {
public:
//虚函数＋函数名/参数/返回值-》重写/覆盖
  virtual void BuyTicket()
  {
      cout <<_name << "student:买票-半价50 ￥" <<endl;
  }
};
int main()
{
      Person *sp=new Person();
      sp->BuyTicket();
      Student * pt =new Student();
      pt->BuyTicket();
}

通过不用对象执行不同的虚函数

#include <iostream>/( 包含了大部分的头文件
using namespace std;//命名空间相当于全局声明std输出流
class Person {
public:
//虚函数
virtual void BuyTicket()
{
   cout <<_name <<"Person:买票-全价100￥" <<endl;
}
protected :
string _name;
};
class Student : public Person {
public:
   //虚函数＋函数名/参数/返回值-》重写/覆盖
   virtual void BuyTicket()
   {
      cout <<_name << "student:买票-半价50 ￥" << endl;
   }
};
int main()
{
     Person *sp=new Person();
     sp->BuyTicket();
     Student * pt =new student();
     pt->BuyTicket();
}

重写析构函数

#include <iostream>//包含了大部分的头文件
using namespace std;//命名空间相当于全局声明std 输出流
class Person {
      public:
      virtual ~Person() {cout <<"~Person()" <<endl;}
};
class Student : public Person {
     public:
     virtual ~Student() { cout <<"~Student()" <<endl; }
};
int main()
{
     Person* p1 = new Person ;
     Person* p2 = new Student;
     delete p1;
     delete p2 ;
     return 0;
}

防止重写虚函数

#include <iostream>//包含了大部分的头文件
using namespace std;//命名空间相当于全局声明std输出流
class Person {
public:
    //虚函数
    virtual void BuyTicket() final //声明接口函数不被重写
    {
       cout <<_name << "Person:买票-全价100￥" <<endl;
    }
   protected :
   string _name;
};
class student : public Person {
public:
int main()
{
   Person *sp=new Person();
   sp->BuyTicket();
   student * pt =new student();
   pt->BuyTicket();
}

跟C语言一样：

#include "stdio.h"

int main()

{

const int a;//只读

a = 100;

}

七、函数模板

函数模板跟函数重载类似，区别在于函数模板的类型不确定，还可以强制转换类型：-----泛型编程

template <typename T>
T Myswap(const T a,const T b)
{
   T sp = a+b;
   return sp;
}
int mian()
{
   int a = 90 ;
   int ss = 7;
   string str1 = " 你好！"；
   string str2 = " 中国"；
   cout<< Myswap< char> (a,ss) << endl; //传入参数强转为char
   cout<< Myswap(a,ss)<<endl;  //默认为int类型
   cout<< Myswap(str1,str2)<<endl; //默认额字符串类型
}

String类的简单使用：

#include <iostream>
using namespace std ;
int main()
{
   int a=90;
   int ss=7;
   string str1="一>你好! ";
   string str2="中国";
   cout << a+ss<<endl;
   cout <<str1+str2<<endl;
   if("中国"==str2)
   {
     cout <<"比较"<<endl;
   }
  str1+="很好";//拼接功能
  cout <<"拼接"<<str1<<endl;
  cout<<"跟数组一样单个元素访问"<<str1.at(o)<<endl;l
  str1.append ( ">>>>") ;
  cout <<"插入"<<str1<<endl ;
  str1.clear ( ) ;
  cout <<"清空:"<<str1<<endl;
}

八、带参数的构造函数继承

#include <iostream>
using namespace std;
class A
{
  public:A(int s){
  cout<< "s="<<s<<endl;
}
};
classB: public A
{
 public :
 B(int x):A(x) //A(x)传什么值给Xx就把值传给A的的构造函数
{
 cout<< "X"<<x;
}
};
int main()
{
   A *sp =new A(88) ;
   B*pt =new B( 100 ) ;
}

另有给私有变量传参

#inc1ude <iostream>//头文件
#inc1ude <string.h>
using namespace std;//命名空间
class Anima1 //动物类型
{
  pub1ic://公有的
  Anima1(int x) :a(x)//直传X的值给acl{J
};
void prin(void) 
{
  cout <<a ; 
}
private://私有-int a=999;//私有的-
(
};
int main()
{
   Anima1 *Dog = new Anima1(100) ; //new形式创建一个对象纠Dog->prin( ; 
   delete Dog;/ /释放对象return 0; 
}

C++ 基础