C++学习笔记

目录

• 1、基本知识
• • 1.1 输入输出
  • 1.2 命名空间namespace
• 2、空间申请与释放
• • 2.1 c语言与c++结构体区别
  • 2.2 new和delete
• 3、引用
• • 3.1 介绍
  • 3.2 引用做参数
  • 3.3 引用与指针的区别
• 4、c++函数特性
• • 4.1 函数参数缺省值
  • 4.2 函数重装
• 5、类与对象
• • 5.1 类和对象的声明
  • 5.2 访问修饰符public/protected/private
  • 5.3 友元
  • 5.4 构造方法和初始化列表
  • 5.5 析构函数
  • 5.6 const成员和static成员
  • • 5.6.1 常函数
    • 5.6.2 静态成员

1、基本知识 1.1 输入输出

#include
using namespace std;
int main()
{
        int a;
        cout << "请输入数字n";
        cin >> a;
        cout << "a = " << a << endl;
        return 0;
}

1.2 命名空间namespace

功能： 区分同名变量或者函数
创建： namespace 名字{…}
使用：

1. 命名空间名::变量/函数
2. using namespace xxx

 using namespace std;
 cout << "Hello";

示例程序：

#include
using namespace std;

namespace nsp1{//创建命名空间nsp1
	void show(){
		cout << "nsp1 show" << endl;
	}
}
namespace nsp2{//创建命名空间nsp2
	void show(){
		cout << "nsp2 show" << endl;
	}
}
int main(){
	nsp1::show();
	nsp2::show();
	return 0;
}

2、空间申请与释放 2.1 c语言与c++结构体区别

1. c++声明结构体变量可以不加struct，c语言需要在结构体类型前加struct
2. c语言不可以放函数成员，但可以放函数指针

#include 
using namespace std;
struct Str{
        int a;
        void show(){
                cout << "str show!" << endl;
        }
};
int main(){
        Str str;
        str.a = 12;
        cout << "str.a = " << str.a << endl;
        str.show();
        return 0;
}

2.2 new和delete

#include 
#include 
using namespace std;


int main(){
        //申请单值
        int *p = (int*)malloc(sizeof(int));//
        int *p1 = new int(12);//初始化值为12

        //申请数组
        int *p2 = (int*)malloc(5*sizeof(4));
        int *p3 = new int[4];

        *p = 100;
        *p1 = 1000;

        p2[0] = 3;
        p3[0] = 65;

        free(p);
        delete(p1);

        free(p2);
        delete[] p3;//释放数组加方括号

        return 0;
}

new和malloc的区别： new可以申请对象空间，malloc不可以。

3、引用 3.1 介绍

概念： 引用是c++相对于c语言独有的，作用是给已定义的变量起别名

int a = 12;
int &c = a;//给变量a起别名c。注意，a必须要初始化或者赋值，不然会报错
int &d = c;

注意：

1. 被引用的变量必须初始化或者赋值
2. 声明引用之后，不能再指向其它的变量

其它类型的引用：

//1、常量引用
const int &a = 12; //常量的引用，必须加const，且值不可被改变
//2、数组的引用
int arr[6];
int (&p)[6] = arr;
//3、二维数组引用
int arr[4][5];
int (&p)[4][5] = arr;
//4、指针的引用
int* a = new int(12);
int* (&p) = a;

3.2 引用做参数

#include 
using namespace std;
void add(int &a){//引用做形参
        a++;
}
int main(){
        int a = 12;
        add(a);
        cout << a << endl;//打印13
        return 0;
}

3.3 引用与指针的区别

1. 引用必须初始化，指针可以不用初始化
2. 引用不占内存空间，指针重新开辟内存空间
3. 引用更安全，不可以便宜；指针可以偏移
4. 指针更灵活，直接操作地址，通用c语言和c++

4、c++函数特性 4.1 函数参数缺省值

void fun1(int a = 12, char c = 'f'){...}//全部指定默认值
void fun2(int a, char c, short s = 60){...}//部分指定默认值，规则：从右往左连续指定
int main(){
	fun1();//如果函数指定默认值，可以不用传参
	fun2(12,"f");//如果函数指定默认值，可以不用传参；没指定默认值，一定要传递实参
	return 0;
}

4.2 函数重装

定义： 多个函数，函数名相同，参数列表不同（类型或个数不同）
注意： 返回值不作为重载的判断条件

5、类与对象 5.1 类和对象的声明

注意： 只有静态常量整型成员才可以在类中初始化

class CPeople{
public:
        string name;
        void show(){
			cout << "show..." << endl;
		}
        void toString(){
                cout << "name:" << name << endl;
        }
};

int main(){
        CPeople anker;
        CPeople *tom = new CPeople;

        anker.name = "anker";
        anker.toString();
		
		CPeople().show();//临时对象
			
        tom->name = "tom";
        tom->toString();

        return 0;
}

5.2 访问修饰符public/protected/private

public，共有的，struct是一种特殊的类，成员默认用public修饰
protected，受保护的，类中和子类可见
private，私有的，类中默认用private修饰，仅类中可见

5.3 友元

关键字： friend
友元函数： 在类中把类外的函数声明为友元函数，则类外的函数可以访问类中的私有成员
友元类： 在类A中声明类B为友元类，则类B可以访问类A的私有成员

class CStu{
private:
        int a;//私有成员变量
        void show(){//私有函数
                cout << "a = " << a << endl;
        }
        friend void fun();//友元函数
        friend class CB;//友元类
};
//友元类
class CB{
        CStu s;
public:
        void show(){
                s.a = 49;//访问私有成员变量
                s.show();//访问私有方法
        }
};
//友元函数
void fun(){
        CStu s;
        s.a = 12;//访问私有成员变量
        s.show();//访问私有方法
}

5.4 构造方法和初始化列表

class CPeople{
public:
        string name;
        int age;
        CPeople(){
                name = "sam";
                age = 12;
        }
        CPeople(string name, int age = 12){
                this->name = name;
                this->age = age;
        }
        void show(){
                cout << "name:" << name << " " << "age:" << age << endl;
        }
};

int main(){
        CPeople p1("ancy",15);
        p1.show();

        CPeople *p2 = new CPeople("nick",13);
        p2->show();

        CPeople *p3 = new CPeople;
        p3->show();

        return 0;
}

初始化列表：

#include 
using namespace std;

class CPeople{
        string name;
        int age;
public:
        CPeople(string name,int age):name(name),age(age){}
        void show(){
                cout << "name:" << name << " " << "age:" << age << endl;
        }
};

int main(){
        CPeople p1("sam",13);
        p1.show();
        CPeople *p2 = new CPeople("lisa",12);
        p2->show();
        return 0;
}

初始化顺序： 变量的初始化顺序是从上到下

//错误的初始化示例：
class A{
	int a;//先初始化
	int b;//后初始化
	A():b(12),a(b){}
	//结果：a=未知值，b=12
}
//正确的初始化示例
class A{
	int a;//先初始化
	int b;//后初始化
	A():a(12),b(a){}
	//结果：a=12，b=12
}

5.5 析构函数

#include 
using namespace std;
class Stu{
public:
        Stu(){
                cout << "Stu 无参构造函数" << endl;
        }
        ~Stu(){ //析构函数不能有形参
                cout << "Stu 析构函数" << endl;
        }
};
int main(){
        //Stu st;
        Stu *st = new Stu;
        delete st;
        cout << "end......." << endl;
        return 0;
}

5.6 const成员和static成员 5.6.1 常函数

 void fun() const{...}

特点：

1. 可以使用数据成员，不可以修改数据成员
2. 常对象只能调用常函数，不能调用普通函数

class CStu{
        int a;
public:
        void fun() const{//常函数
                //a = 12;//报错，不能修改成员变量
                cout << "a = " << a < 
5.6.2 静态成员 
特点：
 
静态成员只能在类外进行初始化。可以在普通成员方法中赋值
可以通过类名::静态成员的方法调用
只有静态常量整型数据成员才能在类中声明时直接初始化赋值
静态成员函数，不能用this指针，不能调用普通成员变量