C/C++学习总结

渔戈

已于 2022-07-07 20:45:07 修改

阅读量1.9w

点赞数 1

分类专栏： C/++ 文章标签： c++ c语言学习

于 2022-07-02 17:36:54 首次发布

本文链接：https://blog.csdn.net/FreeTime_9527/article/details/125575633

版权

C/++ 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

C/C++学习

一.C语言有且仅有的四种基本类型

char  字符型,占用一个字节的长度,可以存放1个字符;
int   整型,用来装整数,长度由所在机器而定,通常占4个字节;
float 单精度浮点型
double 双精度浮点型

施加在基本类型上的限定符:

short int a; //int可省略不写
long int a;  //int可省略不写
short限定符尽可能的使int变短,long尽可能的使int变长.
short和int类型不小于16位,int型可以是16位和32位,long型不小于32位,具体由所在机器而定.
signed与unsigned可用来限定char型和所有整型(包括被short或long限定过的整型).
signed整型等价于整型.
unsigned整型使得原有整型长度不变,符号位变成了数据位,仅能表示0和整数.
signed char强制char可以存储有符号整数,unsigned char 强制char可以存储无符号整数,char不加任何限定,则是否有符号根据所在机器而定.

二.类型转换

自动转换:

赋值语句中的自动转换:
float a = 100;
int b = a;
混合运算中的自动转换:
1 + 1.1

自动转换的规则:
short+char-->int
int+unsigned int-->unsigned int
short+char+int+unsigned int -->unsigned int
short+char+int+unsigned int+float-->float
short+char+int+unsigned int+long-->long
float+long-->double

强制转换:

(类型名)表达式
(float)a; //将变量a转换为float类型
(int)(c+d); //把表达式x+y的结果转换为int类型
(float)5;  //将数值5(默认为int类型)转换为float类型
注意:类型转换只体现在结构上,并不会改变被转换变量的类型

三.静态变量:static

#include <iostream>
using namespace std;
void f()
{
    static int a=0;  //static:被static修饰的变量只会被定义一次,函数调用结束后,变量也不会被回收,所以我们重复调用的a是同一个a
    ++a;
    cout<<a<<endl;
}

int main()
{
    for(int i=0;i<=5;++i)
    {
        f();
    }
    return 0;
}

四.指针变量问题

int *p1 = &A;  //定义一个int型的指针变量*p1(指针变量是用来存储地址的)  *p1只能保存整型变量的地址  &:是取地址符,表示的是取A的地址
float *p2 = &B;
char *p3 = &C;

p1 = &D; //将D的地址赋值给p1,也就是我们常说的p1->D

//有时候我们只知道一个指针(如:p1),并不知道该指针所指的变量是谁(D),那我们怎么得到该指针(p1)所存储的值(D)呢?
E=*p1;  //*p1:代表的是取p1所代表的值,由于p1->D,所以我们就拿到了D的值,然后赋值给E.

实例:

//通过指向变量a的指针变量,修改指针变量的值以达到修改变量a的值.
#include <iostream>
using namespace std;
int main()
{
int a=10;
int b =10;
int *a_ = &a;   //定义一个指针变量,并指向变量a
int *b_ = &b;   //定义一个指针变量,并指向变量b
++(*a_);        //指针变量自增.
cout<<a<<endl;
return 0;
}

五.数组

一维数组:

#include<iostream>
using namespace std;

int main()
{
	int a[10] = {0};
	for(int i=0;i<10;++i)
	{
		cout<<a[i]<<" ";	
	}
	cout<<endl;

	int b[10]={1};
	for(int i=0;i<10;++i)
	{
		cout<<b[i]<<" ";
	}
	cout<<endl;

	int c[10] = {1,2,3,4,5,6,7,8,9,10};
	for(int i=0;i<10;i++)
	{
		cout<<c[i]<<" ";
	}
	cout<<endl;

	return 0;
}

一维数组与函数:

#include <iostream>
using namespace std;

void arrayFun(int a[],int n) //传入的是数组和数组长度(结合文件数组与函数2.cpp可以看出:数组的存在就是一个指针,指向第一个元素的指针)
{
	for(int i=0;i<n;++i)
	{
		++a[i];
	}
	for(int i=0;i<n;++i){
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	int a[10] = {1,2,3,4,5,6,7,8,9,10};
	arrayFun(a,10); //a代表的是数组a,但是实际上传入的是数组a第一个元素的地址.
	return 0;
}
对比:
#include<iostream>
using namespace std;

void arrayFun(int *a,int n) //数组的存在就是一个指针,指向第一个元素的指针
{
	for(int i=0;i<n;++i)
	{
		++a[i];
	}
	for(int i=0;i<n;++i)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	int a[10] = {1,2,3,4,5,6,7,8,9,10};
	arrayFun(a,10);
	return 0;
}

指向函数的指针:

#include<iostream>
using namespace std;

int add(int a,int b)
{
	return a+b;
}

int minu(int a,int b)
{
	return a-b;
}

int main()
{
	int (*p)(int,int);  //定义一个指向函数的指针.
	char op ='+';
	if(op=='+')  //if(op=='-')
		p=add;
	else
		p = minu;
	cout<<p(3,4)<<endl;
	return 0;
}

指针型数组:

#include <iostream>
using namespace std;

int main()
{
	int a[10] = {1,2,3,4,5,6,7,8,9,10};
	int *p[10] = {a,a+1,a+2,a+3,a+4,a+5,a+6,a+7,a+8,a+9};
	for(int i=0;i<10;++i)
	{
		cout<<*p[i]<<" ";
	}
	cout<<endl;
	return 0;

}

指针与数组:

实例一:
#include<iostream>
using namespace std;

int main()
{
	int a[10]={1,2,3,4,5,6,7,8,9,10};
	int *p =a;  //指针变量指向数组a的第一个元素,即*p=a[0] ==> *p==1;
	for(int i=0;i<10;++i)
	{
		cout<<*(p+i)<<" ";
	}
	cout<<endl;
}
实例二:
#include<iostream>
using namespace std;

// int main()
// {
// 	char *s1 = "I am a string";
// 	cout<<s1<<endl;
// 	return 0;
// }
// //输出结果为:I am a string


// int main(){
// 	char *s1 = "I am a string";
// 	char s2[] = "I am a string too";
// 	*s1 ="S";
// 	cout<<s1<<endl;
// 	return 0;
// }
// //输出结果:报错,因为*s1拿到的其实是第一个字符的地址

int main(){
	char *s1 = "I am a string";
	char s2[] = "I am a string too";
	*s2 ='S';
	cout<<s2<<endl;
	return 0;
}
//输出结果:S am a string too

二维数组:

实例一:
#include<iostream>
using namespace std;

int main()
{
	int b[4][3]={
				{1,2,3},
				{4,5,6},
				{7,8,9},
				{10,11,12}
			  };
	for(int i=0;i<4;++i)
	{
		for(int j=0;j<3;++j)
		{
			cout<<b[i][j]<<"\t";
		}
		cout<<endl;
	}
	return 0;
}
实例二:
#include<iostream>
using namespace std;

void array2D(int a[][3],int n) //n指出数组第一位的长度.  
{
	for(int i=0;i<n;++i){
		for(int j=0;j<3;++j)
		{
			cout<<a[i][j]<<"\t";
		}
		cout<<endl;
	}
}

int main()
{
	int b[4][3] = {
		{1,2,3},
		{4,5,6},
		{7,8,9},
		{10,11,12}
	};
	array2D(b,4);
	return 0;
}

二维字符串数组:

实例1:
#include<iostream>
using namespace std;

int main()
{
	char *s2D[] = {
		"I",
		"am",
		"a",
		"string"
	};

	for(int i=0;i<4;++i)
	{
		cout<<s2D[i]<<endl;
	}
	return 0;
}

实例2:
#include<iostream>
using namespace std;

void array2D(char *s2D[])
{
	for(int i=0;i<4;++i)
	{
		cout<<s2D[i]<<endl;
	}
}

int main()
{
	char *s2D[] = {
		"I",
		"am",
		"a",
		"string"
	};
	array2D(s2D);
	return 0;
}

六.结构体:不同类型变量组合在一起构成的变量.

类型定义(typedef)

typedef用来给数据类型取新的名字.

实例:

#include<stdio.h>
int main()
{
	typedef int MYINT;
	MYINT a = 0;
	printf("%d\n", a);

	typedef char MYCHAR;
	MYCHAR ch = 'C';
	printf("%c\n",ch );
	return 0;
}

指向结构体的指针:

#include<stdio.h>

typedef struct 
{
	int x;
	int y;
	
}Point;

int main()
{
	Point point;
	Point *p;
	p = &point;
	p->x = 10;
	p->y = 11;
	printf("%d,%d",p->x,p->y);
	return 0;
}

自引用结构:

#include<stdio.h>
typedef struct Point
{
	int x;
	int y;  
	struct Point *next;
}Point;

int main()
{
	Point p1,p2,p3,p4,p5;
	Point *p;
	p1.x = 1;p1.y=0;
	p2.x = 4;p2.y=1;
	p3.x = 2;p3.y=4;
	p4.x = 3;p4.y=2;
	p5.x = 1;p5.y=6;

	p1.next = &p2;
	p2.next = &p3;
	p3.next = &p4;
	p4.next = &p5;
	p5.next = NULL;

	for(p = &p1;p!=NULL;p=p->next)
		printf("(%d, %d)\n",p->x,p->y);;

	return 0;
}

定义结构体的两种方式:

typedef struct
{
    int a;
    float b;
    char c;
    ... ...
}结构体名;

typedef struct 结构体名
{
    int a;
    float b;
    char c;
    struct 结构体名 *d;
    ......
}结构体名;

实例:

typedef struct 
{
    int a;
    float b;
    char c;
}S;

//怎么使用我们定义的结构体呢?
S s; //定义了一个类型为S,名字为s的结构体变量,你可以类比Java中类的实例化.

//为结构体S进行赋值
s.a = 1;  
s.b = 12.11;
s.c = 'ABC';
R = s.a;  // 取值,R的值为1

定义结构体的四种格式:

方式一:
#include<stdio.h>

int main()
{
	struct {int x;int y;} point;//point是我们定义的结构体的名字 
	point.x = 10;
	point.y = 11;
	printf("%d,%d",point.x,point.y);
	return 0;
}

方式二:
#include<stdio.h>

int main()
{
	typedef struct {int x;int y;} Point;// 定义一个Point类型的结构体
	Point point;
	point.x = 10;
	point.y = 11;
	printf("%d,%d",point.x,point.y);
	return 0;
}
方式三:(常用)
#include<stdio.h>

// 定义一个Point类型的结构体
typedef struct 
{
	int x;
	int y;
}Point;

int main()
{
	Point point;  //实例化
	point.x = 10;
	point.y = 11;
	printf("%d,%d",point.x,point.y);
	return 0;
} 
方式四:(常用)
#include <stdio.h>

struct Point
{
	int x;
	int y;
};

int main()
{
	struct Point point; //实例化
	point.x=10;
	point.y=11;
	printf("%d,%d",point.x,point.y);
	return 0;
}

七.类

类的实现:

实例一:
#include<iostream>
using namespace std;

class Point
{
public:  //公有属性
	Point()  //这是一个构造函数
	{
		this->x = 0;
		this->y = 0;
		this->next = NULL;
	}
	int x;
	int y;
	Point *next;
};

int main()
{
	Point *P = new Point; //类的初始化
	cout<<P->x<<","<<P->y<<endl;
	return 0;
}

实例二:
#include<iostream>
using namespace std;

class Point
{
public://公有属性
	Point()
	{
		x = 0;
		y = 0;
		next =NULL;
	}
private://私有属性  私有属性不能被直接访问
	int x;
	int y;
	Point *next;
};

int main(){
	Point P;
	P.x;  //直接访问私有属性是不被允许的,所以程序会报错!!
	return 0;
}
实例三:
#include<iostream>
using namespace std;

class Point
{
public:
	Point()
	{
		this->x = 0;
		this->y = 0;
		this->next = NULL;
	}
	int getX();  //访问私有变量x的方法
	int getY();  //访问私有变量y的方法
	void inPutX(int x);//设置私有变量x的方法
	void inPutY(int y);//设置私有变量y的方法
	Point *getNext();
	void inPutNext(Point *next);
private:
	int x;
	int y;
	Point *next;
};

//定义私有属性变量的get和input方法
int Point::getX()
{
	return this->x;
}

int Point::getY()
{
	return this->y;
}

void Point::inPutX(int x)
{
	this->x = x;
}
void Point::inPutY(int y)
{
	this->y=y;
}
Point *Point::getNext()
{
	return this->next;
}
void Point::inPutNext(Point *next)
{
	this->next = next;
}

//主函数:
int main(){
	Point P1,P2;  
	P1.inPutX(100);
	cout<<P1.getX()<<endl;
	cout<<P1.getNext()<<endl;

	P1.inPutNext(&P2);
	cout<<P1.getNext()<<endl;
	return 0;
}

八.函数

函数的结构与调用:

返回值类型 函数名(参数列表)
{
    声明和语句;
    return X;
}
调用方法:函数名(参数列表)

实例:

int add(int a,int b)
{
    return a+b;
}

//调用add函数:
result = add(1,2);

另外一种无返回值的函数:

void F()
{
    ...
}
调用:F();

实例:

int result = 0;
void getResult(int r)
{
    ++r;
}
//调用getREsult方法:
getResult(result);


//猜测一下,r的值是多少?
//结果是r的值还是为0,其实我们并没有改变result的值,我们改变的只是r的值,那如果我们想要改变result的值该怎么办呢?(C++版本):
int result = 0;
void getResult(int &r)  //引用型定义,&r表示的是直接引用result这个变量,所以修改的也是result的值了
{
    ++r;
}
//调用getREsult方法:
getResult(result);

//C版本:
int result = 0;
void getResult(int *r)  //参数为指针变量用于存储变量的地址,所以也是直接对传进来的参数的值进行修改的
{
    ++(*r);
}
//调用getREsult方法:
getResult(&result);

//定义指针型变量的引用型定义函数(C++版本):
int *p = NULL;
void getResult(int *&P)
{
    ...
    P = q;
    ...
}
调用:getResult(p);

//指针变量的引用型定义函数:(C版本)
int *p = NULL;
void getResult(int **P)
{
    ...
    *P = q; //*P其实代表的就是p
    ...
}
调用:getResult(&p);

九.时间复杂度

普通函数的时间复杂度分析:

一次循环运行时间是循环内语句的运行时间乘以循环次数;
嵌套循环运行时间为最内层语句执行次数乘以总循环次数;
并列的两个循环运行时间与执行次数数量级别大的那个相同;

递归函数的时间复杂度分析:

对形如:T(n)=aT(n/b) + f(n)的递归方程,其中(f(n)是确定的正函数)有:
$\left\{ \begin{array}{c} T(n) = O(n^{log_ba}) \ \ \ \ O(n^{log_ba})>O(f(n))\\ T(n) = O(f(n)logn) \ \ \ \ O(n^{log_ba})=O(f(n))\\ T(n) = O(f(n)) \ \ \ \ O(n^{log_ba})<O(f(n))\\ \end{array} \right.$

十.格式化输入输出

格式化输出:printf

实例:

#include <stdio.h>

int main()
{
	int a =10;
	float b = 1.1;
	char c = 'c';
	char str[10] = "string111";

	printf("int var :%d\n",a);
	printf("float var:%f\n",b);
	printf("char var:%c\n", c);
	printf("string var:%s\n",str );

	return 0;
}

格式控制符

%d %f %c %s

格式化输入:scanf

实例

//c版本
#include <stdio.h>
int main()
{
	int a;
	float b;
	char c;
	char str[10];

	scanf("%d",&a);
	scanf("%f",&b);

	getchar();//吞掉上一个遗留下来的换行符,以便后续代码输入字符
	scanf("%c",&c);
	scanf("%s",str);

	printf("int var:%d\n", a);
	printf("float var:%f\n",b );
	printf("char var:%c\n",c );
	printf("string var:%s\n",str );

	return 0;
}


//c++版本
#include<iostream>
using namespace std;

int main()
{
	int a;
	float b;
	char c;
	char str[10];

	std::cin>>a;
	cin>>b;
	cin>>c;
	cin>>str;

	std::cout<<"int var:"<<a<<endl;
	cout<<"float var:"<<b<<endl;
	cout<<"char var:"<<c<<endl;
	cout<<"string var:"<<str<<endl;

	return 0;
}

字符与字符串的输入输出.

字符输入输出:

输入一个字符:getchar()

输出一个字符:putchar(字符变量或常量)

char ch = getchar();
putchar(ch);

输入一个字符还可用:scanf(输入格式)
输出一个字符还可用:printf(输出格式)
char ch;
sacnf("%c",&ch);
printf("%c",ch);

getchar()和putchar()效率优于scanf()和printf().

字符的输入输出实例:

//c版本:
#include <stdio.h>

int main()
{
	int n;
	char a,b;
	scanf("%d",&n);
	getchar();
	while(n>0)
	{
		scanf("%c%c",&a,&b);
		getchar();
		printf("%c%c\n",a,b );
		--n;
	}
	return 0;
}	

//c++版本

#include<iostream>
using namespace std;

int main()
{
	char ch;
	int i = 1;
	while(true)
	{
		cin>>ch;
		cout<<i<<":"<<(int)ch<<endl;
		++i;
		if((int)ch==10)
		{
			i=1;
		}
	}
	return 0;
}

//cin从键盘缓冲中取字符的时候会过滤掉空格、制表符和回车,这些特性字符不会传给cin

渔戈

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
C/C++学习总结

施加在基本类型上的限定符:二.类型转换自动转换:强制转换:三.静态变量:static四.指针变量问题实例:五.数组一维数组:一维数组与函数:指向函数的指针:指针型数组:指针与数组:二维数组:二维字符串数组:六.结构体:不同类型变量组合在一起构成的变量.类型定义(typedef)typedef用来给数据类型取新的名字.实例:指向结构体的指针:自引用结构:定义结构体的两种方式:实例:定义结构体的四种格式:七.类类的实现:八.函数函数的结构与调用:实例:
复制链接

扫一扫