c++自学笔记(陆续更新)

news2024/11/24 23:01:54

本笔记为从菜鸟教程边学边记录的笔记---》C++ 教程 | 菜鸟教程

面向对象程序设计

封装（Encapsulation）：封装是将数据和方法组合在一起，对外部隐藏实现细节，只公开对外提供的接口。这样可以提高安全性、可靠性和灵活性。
继承（Inheritance）：继承是从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法。这样可以提高代码的复用性和可扩展性。
多态（Polymorphism）：多态是指同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性。
抽象（Abstraction）：抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。

hello word

#include <stdio.h>
#include <windows.h>
#include <iostream>
using namespace std;
int main()
{
   SetConsoleOutputCP(65001);
   cout << "hello world!"<<endl; //也可以用\n代替endl;都是换行的意思
   return 0;
}

变量别名！

#include <iostream>
using namespace std;
int main()
{
    typedef int it;//int的别名 是it
    it a;//以后就可以用it来定义变量
}

枚举类型

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

#include <iostream>
using namespace std;
int main()
{
   enum {green,blue=5,red} c;
   c=red;
   cout <<"sdsdds" <<c;
}

类型转换-静态转换

#include <iostream>
#include <typeinfo>
#include <windows.h>
using namespace std;
int main()
{
   SetConsoleOutputCP(65001);
   //这个是c++的断点 这配置c语言也支持断点
   int a = 10;
   //静态转换 数据 类型；
   float b=static_cast<float>(a);
   cout <<b<<"是"<<typeid(b).name()<<"类型";

}

你像打印 i 就是int 打印 f 就是float;就是类型首字母

类型转换-常量转换

#include <iostream>
#include <typeinfo>
#include <windows.h>
using namespace std;
int main()
{
   SetConsoleOutputCP(65001);
   //这个是c++的断点 这配置c语言也支持断点
   const int a = 10;
   //常量转换
   int &b=const_cast<int&>(a);
   b=11;
   cout << b;
}

extern关键词用法

顺带你还知道下 .cpp怎么引入另一个.cpp的文件。

参考博主写的另一篇博文===》c++的extern用法理解_雪狼之夜的博客-CSDN博客

局部变量

局部作用域：在函数内部声明的变量具有局部作用域，它们只能在函数内部访问。局部变量在函数每次被调用时被创建，在函数执行完后被销毁。

#include <iostream>
using namespace std;
int main()
{
  int a=2;
  cout<<"局部变量a="<<a<<endl;
}

全局变量

全局作用域：在所有函数和代码块之外声明的变量具有全局作用域，它们可以被程序中的任何函数访问。全局变量在程序开始时被创建，在程序结束时被销毁。

#include <iostream>
using namespace std;
int a=2;
int main()
{
  cout<<"全局变量a="<<a<<endl;
}

块变量

块作用域：在代码块内部声明的变量具有块作用域，它们只能在代码块内部访问。块作用域变量在代码块每次被执行时被创建，在代码块执行完后被销毁。

#include <iostream>
using namespace std;

int main()
{
   int a=1;
   {
      int a=2;
      cout<<"块变量a="<<a<<endl;
   }
  cout<<"函数变量a="<<a<<endl;
}

<string>

#include <iostream>
#include <string>
using namespace std;

int main()
{
   string a="hello world";//或者写成string a("hello world") 等效
   a+=" 你好啊";
   cout<< a<<endl;
}

类

#include <iostream>
using namespace std;
class Box{
   public:
      int a;
      int b;
      int chen(void){ //申明和定义在类里面
         return a*b;
      };
      void setVal(int,int);//先在类里面申明
      
};
void Box::setVal(int x,int y){//在类外面定义   范围解析运算符 :: 
   a=x;
   b=y;
};
int main(){
   Box box1;
   box1.setVal(3,2);
   cout << box1.chen();
}

类私有成员

#include <iostream>
using namespace std;
class Box{
   private://类私有，只有成员可以调用 也就是说你不可以通过box1.a来调用 ,这些变量其实你默认不用写private 这个变量，只要放在最上面他默认就是 私有
      int a,b;
   public://
      int c=10;
      int chen(void){ //申明和定义在类里面
         return a*b;
      };
      void setVal(int,int);//先在类里面申明
};
void Box::setVal(int x,int y){//在类外面定义
   a=x;
   b=y;
};
int main(){
   Box box1;
   cout<< box1.c<<endl;
   box1.setVal(3,2);
   cout << box1.chen();
}

类

看博主另一篇博文=》c++类笔记_雪狼之夜的博客-CSDN博客

.cpp调用 .cpp和h的demo

看博主另一篇博文=》.cpp调用 .cpp和h的demo_雪狼之夜的博客-CSDN博客

数组

C++ 不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。

你不能简单地返回指向局部数组的指针，因为当函数结束时，局部数组将被销毁，指向它的指针将变得无效。

C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。

#include "head.h"
int* arrFun(){
   static int arr[3]={5,4,10};
   return arr;
} 

int main()
{
  int *arr=arrFun();
  cout<<arr[1];
}

函数动态分配数组

使用动态分配数组需要在函数内部使用 new 运算符来分配一个数组，并在函数结束时使用 delete 运算符释放该数组

#include "head.h"
int* arrFun(int size){
   int* arr=new int[size]; //这里也可以直接写3
   arr[0]=1;
   arr[1]=10;
   arr[2]=3;
   return arr;
} 

int main()
{
  int *arr=arrFun(3);
  cout<<arr[1];
  delete[] arr;
}

数组指针

#include <iostream>
using namespace std;
const int Max=3;
int main(){
   int arr[Max]={100,200,300};
   int *p;
   p=arr;
   for(int i=0;i<Max;i++){
      cout << "arr["<<i<<"]="<<*p<<endl;
      p++;
   }
}

今天也算理解了，p=arrr其实等价于p=&arr[0] ，也就是说数组指针也可以变成下面这种写法。

我写一个从a[2]往a[0]输出的操作，你们理解下

#include <iostream>
using namespace std;
const int Max=3;
int main(){
   int arr[Max]={100,200,300};
   int *p;
   p=&arr[2];//等价于p=&arr[0]  也就是说
   for(int i=0;i<Max;i++){
      cout << "arr["<<i<<"]="<<*p<<endl;
      p--;
   }
}

数组指针另一种写法

#include <iostream>
using namespace std;
const int Max=3;
int main(){
   int arr[Max]={100,200,300};
   *(arr+2)=500;
   cout <<arr[2]<<endl;
   arr[2]=100;
   cout <<arr[2];
}

*(arr+2)其实就等于 arr[2]; 也就说说等价于下面

#include <iostream>
using namespace std;
const int Max=3;
int main(){
   int arr[Max]={100,200,300};
   int *p;
   p=arr;
   cout<< *(p+2);
}

C++ 指向指针的指针

#include "head.h"
int main(){
   int a=3000;//(值,物理地址) (3000,0x62ff08)
   int *p;
   p=&a;//p(0x62ff08,3000)
   int **pp;
   pp=&p;
   cout<<"a:"<<"("<<a<<","<<&a<<")"<<endl;
   cout<<"p:"<<"("<<p<<","<<*p<<")"<<endl;
   cout<<"pp:"<<"("<<pp<<","<<**pp<<")";
}

引用

#include "head.h"

int main()
{
   int a,b;
   int& x=a;//引用
   a=3;
   int *y;//指针
   y=&b;
   b=10;
   cout<<x<<endl;
   cout<<*y<<endl;
   y=&a;
    cout<<*y<<endl;
}

指针交换值

#include <iostream>
using namespace std;
int main()
{
   extern void ptrFun(int*,int*);
   int a=1,b=5;
   ptrFun(&a,&b);
   cout<<"a:"<<a<<endl;
   cout<<"b:"<<b;
}
void ptrFun(int *x,int *y){
   int a;
   a=*x;
   *x=*y;
   *y=a;
}

引用交换值

#include <iostream>
using namespace std;
int main()
{
   extern void ptrFun(int&,int&);
   int a=1,b=5;
   ptrFun(a,b);
   cout<<"a:"<<a<<endl;
   cout<<"b:"<<b;
}
void ptrFun(int& x,int& y){
   int a;
   a=x;
   x=y;
   y=a;
}

引用改变数组值

// #include <iostream>
// using namespace std;
#include "head.h"
double arr[]={10.23,55,17};
int main()
{
   extern double& arrFun(int);
   arrFun(1)=11.77;
   cout << arr[1];
}
double& arrFun(int x){
   double& ref=arr[x];
   return ref;
}