语言学习笔记

认识c++

C++（c plus plus）是一种计算机高级程序设计语言，由C语言扩展升级而产生，最早于1979年由本贾尼·斯特劳斯特卢普在AT&T贝尔工作室研发。

C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计。 C++几乎可以创建任何类型的程序：游戏、设备驱动程序、HPC、云、桌面、嵌入式和移动应用等。 甚至用于其他编程语言的库和编译器也使用C++编写。
——百度百科

这个图标就是c++：
image
\(\scriptsize\color{grey}{c++图标}\)

进入c++，我们会看见以下图像：
image

\[\scriptsize\color{grey}{c++内部} \]

键盘按Ctrl+N新建一个文件
image

\[\scriptsize\color{grey}{新建文件} \]

然后就可以打代码了！

语言入门

理论

  1. //后面的文字是注释，程序不会运行
  2. 第一行是头文件，相当于一个工具箱，iostream就是它的工具箱（包含输入输出流），可以根据所需写不同的工具箱，如bits/stdc++.h，stdlib等。
  3. 第二行是命名空间，没有它就要在每句前打上std::
  4. 第三行是主函数，在编译程序的时候，是从这一行开始的，如果没有它有可能都运行不了程序，所以它很重要。
  5. 第四行与第七行是一对大括号（函数体），所有代码都需在花括号内执行。
  6. 第六行是返回值，就是（主函数）结束后返回0值，就代表程序顺利结束了

在大括号内，return 0;前就可以编写代码了。

样例

image
代码：

#include<bits/stdc++.h>//头文件 
using namespace std;//命名空间 
int main(){//主函数 
	//这里写代码 
	return 0;//返回值 
}

编译&运行

我们应该可以注意到c++顶上的工具栏：
image

\[\scriptsize\color{grey}{工具栏} \]

从前到后依次为：
image
新建 打开 保存 全部保存 关闭 全部关闭 | 打印 || 上一步 下一步 || 搜索 替换 | 跳至函数 跳至指定行 || 添加 移除 | 项目属性 | 编译 运行 编译运行 全部重新编译 | 调试 停止执行 | 性能分析 删除性能信息

c++程序要先编译才能运行，所以我们第一次要点击编译运行image，后续如果程序没有改动可以点击运行image

点击编译运行后我们会发现出现一个保存框，功能如图所示
image

保存后会弹出一个黑框，先在里面输入（程序中的cin/scanf），然后会显示程序的输出
image
源程序：

点击查看程序 
#include<bits/stdc++.h>//头文件 
using namespace std;//命名空间 
int main(){//主函数 
	//这里写代码
	int a,b;
	cin>>a>>b;
	cout<<a+b; 
	return 0;//返回值 
}

变量

变量的定义

格式：

变量类型 变量名

变量类型有哪些？
C++中的基本数据类型有：整数类型、浮点类型、字符类型、布尔类型。

整数类型
类型 大小/字节 大小范围
int 4 \(-2^3\)\(^1\) \(～\) \(2^3\)\(^1\)
short 编译系统为32位时，long类型和int类型相同 编译系统为16位或64位时，则long>=int
long 8 \(-2^6\)\(^4\) \(～\) \(2^6\)\(^4\)
long long 8 \(-2^6\)\(^3\) \(～\) \(2^6\)\(^3\)
浮点类型
类型 大小/字节 有效数字 取值范围 指数长度 尾数长度
float 4 6-7 \(-3.4*10(-38)～3.4*10(38)\) 8 位 23
double 8 15-16 \(-1.7*10(-308)～1.7*10(308)\) 11 位 52
long double 16 18-19 \(-1.2*10(-4932)～1.2*10(4932)\)
字符类型

char
字符类型保存的就是一些字母、数字、字符等符号。每一个字符占用1字节，共8个比特位。因为保存的是一些字母等符号，所以在计算机内存中仍然是以整数值的形式保存，即以ASCII码形式保存。
string
使用 string 类需要包含头文件<string>
详解地址

类型 大小/字节 大小范围
char 1 \(-128～127\)
string 动态开量 每一位\(-128～127\)
布尔类型
类型 大小/字节 大小范围
bool 1 \(0～1\) (true/false)

输入输出

cin和cout

cin可以直接输入，格式如下：

int a,b;
cin>>a;
cin>>a>>b;

cout可以直接输出，格式如下：

scanf和printf

specifier（说明符）

  • %i、d 十进制有符号整数（整数不输出符号）；
  • %u 十进制无符号整数；
  • %o 无符号以八进制表示的整数（不输出前缀0）；
  • %x、%X 无符号以十六进制表示的整数（不输出前缀Ox）；
  • %f 十进制浮点数；
  • %a、A 以十六进制表示的浮点数（C99）
  • %e、%E 以十进制指数形式表示的浮点数；
  • %g、%G 把输出的值按照%e或者%f类型中输出长度较小的方式输出；
  • %c 单个字符；
  • %s 字符串；
  • %n 返回对函数的此调用迄今为止写入的字符数；
  • %p 指针的值；
  • %% %符号。

scanf可以输入要定义格式，字符串" "为输入变量类型(specifier叠加在一起)

int a,b;
scanf(“%d”, &a);
scanf(“%d%d”, &a, &b);
//scanf(“<格式化字符串>”, &<变量>);

printf可以输出要定义格式，字符串" "为输入变量类型(specifier叠加在一起)

int a,b;
printf(“%d”, a);
printf(“%d%d”, a, b);
//printf(“<格式化字符串>”, <变量>);

例题1

luogu P1001 A+B Problem

点击查看题目

题目背景

强烈推荐新用户必读帖。

不熟悉算法竞赛的选手请看这里：

算法竞赛中要求的输出格式中，不能有多余的内容，这也包括了“请输入整数 \(\bm a\) 和 \(\bm b\)” 这一类的提示用户输入信息的内容。若包含了这些内容，将会被认为是 Wrong Answer，即洛谷上的 WA。在对比代码输出和标准输出时，系统将忽略每一行结尾的空格，以及最后一行之后多余的换行符。

若因此类问题出现本机（看起来）AC，提交 WA 的现象，请勿认为是洛谷评测机出了问题，而是你的代码中可能存在多余的输出信息。用户可以参考在题目末尾提供的代码。

另外请善用应用中的在线 IDE 功能，以避免不同平台的评测中所产生的一些问题。

还有一点很重要的是，请不要在对应的题目讨论区中发布自己的题解，请发布到题解区域中，否则将处以删除或禁言的处罚。若发现无法提交题解则表明本题题解数量过多，仍不应发布讨论。

题目描述

输入两个整数 \(a, b\)，输出它们的和（\(|a|,|b| \le {10}^9\)）。

注意

  1. Pascal 使用 integer 会爆掉哦！
  2. 有负数哦！
  3. C/C++ 的 main 函数必须是 int 类型，而且 C 最后要 return 0。这不仅对洛谷其他题目有效，而且也是 NOIP/CSP/NOI 比赛的要求！

好吧，同志们，我们就从这一题开始，向着大牛的路进发。

任何一个伟大的思想，都有一个微不足道的开始。

输入格式

两个以空格分开的整数。

输出格式

一个整数。

样例1

输入

20 30

输出

50

提示

本题各种语言的程序范例：

点击查看代码

C

#include <stdio.h>

int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    printf("%d\n", a+b);
    return 0;
}

C++

#include <iostream>
#include <cstdio>

using namespace std;

int main()
{
    int a,b;
    cin >> a >> b;
    cout << a+b << endl;
    return 0;
}

Pascal

var a, b: longint;
begin
    readln(a,b);
    writeln(a+b);
end.

Python2

s = raw_input().split()
print int(s[0]) + int(s[1])

Python3

s = input().split()
print(int(s[0]) + int(s[1]))

Java

import java.io.*;
import java.util.*;
public class Main {
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int a = cin.nextInt(), b = cin.nextInt();
        System.out.println(a+b);
    }
}

JavaScript （Node.js）

const fs = require('fs')
const data = fs.readFileSync('/dev/stdin')
const result = data.toString('ascii').trim().split(' ').map(x => parseInt(x)).reduce((a, b) => a + b, 0)
console.log(result)
process.exit() // 请注意必须在出口点处加入此行

Ruby

a, b = gets.split.map(&:to_i)
print a+b

PHP

<?php
$input = trim(file_get_contents("php://stdin"));
list($a, $b) = explode(' ', $input);
echo $a + $b;

Rust

use std::io;

fn main(){
    let mut input=String::new();
    io::stdin().read_line(&mut input).unwrap();
    let mut s=input.trim().split(' ');

    let a:i32=s.next().unwrap()
               .parse().unwrap();
    let b:i32=s.next().unwrap()
               .parse().unwrap();
    println!("{}",a+b);
}

Go

package main

import "fmt"

func main() {
    var a, b int
    fmt.Scanf("%d%d", &a, &b)
    fmt.Println(a+b)
}

C# Mono

using System;

public class APlusB{
    private static void Main(){
        string[] input = Console.ReadLine().Split(' ');
        Console.WriteLine(int.Parse(input[0]) + int.Parse(input[1]));
    }
}

Visual Basic Mono

Imports System

Module APlusB
    Sub Main()
        Dim ins As String() = Console.ReadLine().Split(New Char(){" "c})
        Console.WriteLine(Int(ins(0))+Int(ins(1)))
    End Sub
End Module

Kotlin

fun main(args: Array<String>) {
    val (a, b) = readLine()!!.split(' ').map(String::toInt)
    println(a + b)
}

Haskell

main = do
    [a, b] <- (map read . words) `fmap` getLine
    print (a+b)

Scala

object Main extends App {
    println(scala.io.StdIn.readLine().split(" ").map(_.toInt).sum)
}

Perl

my $in = <STDIN>;
chomp $in;
$in = [split /[\s,]+/, $in];
my $c = $in->[0] + $in->[1];
print "$c\n";

code

#include<bits/stdc++.h>
using namespace std;
int main(){
	int a,b;
	cin>>a>>b;
	cout<<a+b;
	return 0;
}

判断与循环

判断

if语句

判断语句为if，在下面还可以接else（注：有多个其他情况第二个至倒数第二个if前都要加else）
有点懵？让我们写几个样例代码

if(/*判断条件1*/){
//语句1
}

if(/*判断条件1*/){
//语句1
else{//不符合判断条件1的情况
//语句3
}

if(/*判断条件1*/){
//语句1
}else if(/*判断条件2*/){//如果判断条件1不成立才判断判断条件2
//语句2
}else{//判断条件1、2都不符合
//语句3
}

拓展阅读：switch

switch语句从字面上讲，可以称为开关语句
是一种多分支选择结构，一般与case、break、default配合使用，对流程进行控制。
switch语句的语法格式如下：

switch(表达式){ 
    case 常量表达式1:  语句1;
    case 常量表达式2:  语句2;
    …… 
    case 常量表达式n:  语句n;
    default:  语句n+1;
}

switch嵌套
switch语句可以嵌套，也就是在switch语句中的入口处理语句中又包含了switch语句。case与default标号是与包含它的最小的switch相联系的。例如：

int a,b;
//……
switch(a)
{
    case 1 ://
    case 2 :
    switch(b)
    {    //嵌套switch
    case 1:
    case 2:
    default:
    }
    case 3:
}

switch语句规则

  1. case标签必须是常量表达式(constantExpression)，如62或者'8'等。
  2. case标签必须是惟一性的表达式；也就是说，不允许两个case具有相同的值。
  3. 在case后，允许有多个语句，可以不用{}括起来。
  4. 各case和default子句的先后顺序可以变动，而不会影响程序执行结果。
  5. default子句可以省略不用。

switch语句格式解释

  1. switch:启用当前switch语句
  2. 表达式:一般接收具体的变量
  3. case：需要将当前的case的值和switch中表达式进行比较,是否匹配
  4. break： 表示结束,中断 switch语句
  5. default：case后面都不匹配,执行default

循环

循环分为while循环、do-while循环和for循环

while循环和do-while循环

while循环是先判断条件，符合再执行语句

while(/*判断条件*/){
//语句
}

do-while循环是先执行语句，符合再判断条件（不符合就跳出）

do{
//语句
}while(/*判断条件*/)

for循环

for循环例子：

for(int i=/*起始值，变量名可以改*/;i<=/*结束值*/;i++/*i-=n,i+=n，i*=n,i/=n(关于i的算式皆可以，不要死循环)*/){
//语句
}

拓展：#define

#define很简单，结构如下

#include<bits/stdc++.h>
using namespace std;
#define ll long long
/*
从这里以下我们想用 long long 可以直接打 ll
如 long long a 可以打为 ll a
*/
int main()...

看懂了没有？#define其实就是重命名一个语句

拓展：火车头

加在正常头文件前可给程序加速

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)

拓展：加速cin&cout

代码如下：

#include<bits/stdc++.h>
using namespace std;
int main() {
	// 关闭输入输出缓存，使效率提升
	ios::sync_with_stdio(false);
	// 解除cin和cout的默认绑定，来降低IO的负担使效率提升
	cin.tie(NULL); cout.tie(NULL);
	return 0;
}

拓展：快读快写

inline int read(){
	int x=0,f=1;char ch;
	ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=(x<<3)+(x<<1)+(ch^48);
		ch=getchar();
	}
	return x*f;
}
inline void write(int x) {
  static int st[35];
  int top=0;
  do{
    st[top++]=x%10,x/=10;
  }while(x);
  while(top)putchar(st[--top]+48);
}
//调用
a=read();
write(a);
posted @ 2023-02-21 16:54  ccrui  阅读(52)  评论(0)    收藏  举报