第一周学习笔记C++-CSDN博客

本文链接：https://blog.csdn.net/2301_80370199/article/details/134897738

1.输入函数：

C++中输入函数 "cin >> 一个变量名" ，在这之前要先设置一个变量，要输入的数据类型事先设定好，如:

int a=0;
cin >> a;

要注意的是，cin读取数据时遇到逗号或者空格会停止读取，如：当你运行代码时输入“5，5”时，cin只会读取第一个5，即只有a读取到数值5，b没有读取到数值，只能显示0，最终运行结果是50。

int a=0;int b=0;
cin >> a;cin >> b;
cout << a << b << endl;

关于这一点，个人看法是可以用一个字符变量接收逗号，这样就可以继续读取，下图中字符变量c将逗号读取，若我在运行代码时输入“5，5”，则a可以将第一个5读取，b可以将第二个5读取，最终结果是55。

int a=0;int b=0;char c=0;
cin >> a;cin >> c;cin >> b;
cout << a << b << endl;

冒泡排序：

for (int i = 1; i < n; ++i)
{
	for (int z = 0; z < n - i; ++z)
		if (add[z] > add[z + 1])
		{
			int w = add[z];
			add[z] = add[z + 1];
			add[z + 1] = w;
		}
}

以上是一些做题的笔记。

2.类和对象

类和对象的三大特性：封装、继承、多态

c++认为任何事物都可以作为对象，对象有属性和行为

具有相同性质的对象可以抽象称为“类”

2.1.封装：class/struct 类名{ 访问权限：属性 / 行为 };

（1）将属性和行为作为一个整体，表现生活中的事物

（2）将属性和行为加以权限控制

class和struct 的区别：两者都是用来建立类的，唯一的区别就是两者默认的权限不同,class默认私有权限，struct默认公有权限，除非有说明public: / protected: / private: ( 属性 / 行为)

（3）属性分为：公有属性、保护属性、私有属性，每种属性的访问权限不同

公有属性（public）：类内类外都可以访问（类外可以进行读和写）

保护属性(protected)：类内可以访问，类外不可以访问（类外只可以读，不可以写）

私有属性(private)：类内可以访问。类外不可以访问（类外无法更改无法读取）

const double PI=3.14
class Circle
{
  int m_r  //半径是属性
  double C()
  {
     return 2*PI*m_r; //计算周长是行为
  }
}

封装只是将属性和行为作为一个整体，在主函数中还需要设置一个具体的对象，如C1，并对它的属性进行设置，这个过程被称为 “类的实例化”

int main()
{
  Circle C1;
  C1.m_r=1;
  cout<<"周长为："<<C1.C()<<endl;
  system("pause");
  return 0;
}

2.2 构造函数和析构函数

（1）构造函数和析构函数分别承担两个任务：初始化和清理，两个函数会被编译器自动调用

（2）如果我们不设置构造函数与析构函数，那么编译器会自己设置一个空的构造函数和析构函数，进行空实现

（3）构造函数的主要作用就是在创建对象时为成员属性初始化赋值；析构函数的主要作用是在编译器运行结束需要将对象销毁时执行清理工作

构造函数的特性：类名（）{}

1.构造函数名与类名相同

2.构造函数为无返回值类型

3.对象实例化时编译器自动调用相对应的构造函数

4.构造函数支持函数重载

5.无须手动调用，只能调用一次

class Person
{
public:
  int m_age;
  Person()// 构造函数
  {
    m_age=1;
    cout<<"这是构造函数"<<endl;
  }
  ~person()// 析构函数
  { 
    cout<<"这是析构函数"<<endl;
  }
}

析构函数的特性：~类名（）{}

1.析构函数时在类名前加上字符~

2.析构函数无参数无返回值类型

3.析构函数不能重载

4.一个类只能有一个析构函数，若为显式定义，系统会自动调用默认的析构函数

5.对象生命周期结束时，C++编译系统会自动调用析构函数。

拷贝构造函数：一个构造函数复制原先的构造函数的所有成员属性一个类（相同的类对象名）

Person(int age)//有参构造函数
{
  m_Age=age;
}
Person(Person &p)//将上一个构造函数的成员属性拷贝到这个构造函数
{
  m_Age=p.m_Age;
}

相当于把一个人的所有特征复制到另一个人身上

成员变量和成员函数是分开储存的：

在C++中，类内的成员变量和成员函数分开储存，只有非静态成员变量才属于类的对象上

class Person
{
public:
  int m_age;//非静态成员变量，属于类的对象上
  static string m_name;//静态成员变量，不属于类的对象上
  void fun(){}//非静态成员函数，不属于类的对象上
  static void show(){}//静态成员函数，不属于类的对象上
}

2.3 this指针

类是用来描述对象的，本身不占用内存，但是类实例化出来的对象，需要分配物理内存来储存类变量，因此对象中的成员变量越多，创建的对象越多，所占用的内存就越大。为了解决这一问题，我们可以使用this指针，让该指针指向当前对象，用指针去访问。

（1）this指针的特性：

1.this指针的类型：类类型*const（常变量），在成员函数中，不能给this指针赋值。

2.只能在成员函数内部使用

3.对象调用函数时，将对象的地址作为实参传给this指针，所以对象中不存储this指针。

4.this指针是一个隐含指针形参，一般情况下由编译器自动传递。

5.this指针存放在栈上

6.当发生名称冲突时，可以用this指针来解决并区分

7.在非静态成员函数中返回对象本身时，可以使用return *this

class Person
{
  public:
    Person(int age)
      {
        this->age=age;//age与构造函数的形参是同意同一个
      }
    Person& Personaddage(Person &p)//拷贝构造函数，要返回this本体，需要以一个引用的方式 
                                   //Person&进行返回
     { 
       this->age+=p.age;
       return *this;
     }
    int age;//这个age与this->age是同一个
}

2.4 友元 friend

作用：让一个类或者函数访问另一个类中的私有成员

友元的三种实现：全局函数做友元

（1）友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

（2）特性：

1.友元函数可访问类的私有和保护成员，但不是类的成员函数友元函数不能用const修饰
2.友元函数可以在类定义的任何地方声明
3.一个函数可以是多个类的友元函数
4.友元函数的调用与普通函数的调用和原理相同

类做友元

（1）如果构造两个不同的类，class A class B,并在B的内部中声明friend A，那么类A可以直接访问类B的私有成员以及私有函数。

(2)特性：

1.友元关系是单向的，不具有交换性

即上述中类A可以直接访问B的私有空间，类B则不能访问A的私有空间。

2.有元关系不具备传递性